The majority of hunter-gatherers only work about 4 hours a day.

Actually, this wouldn't work on most modern processors.

Due to interaction with peripherals, there is a minimum, to have your bios able to work and talk to them, depending on the interface, for example, Hypertransport on early AMDs didn't allow a CPU less than 800MHz, or wacky stuff started to happen. Intel would have the same sorts of problems.

Hrm, while somewhat different, that last paragraph reminds me remarkably about Apple, seeming to trying and reinvent that idea.

Speaking as a long time ago calculator hacker. If you can't do the math itself, you frankly, aren't doing yourself any favors by using a calculator. A calculator is a useful shortcut, if you know what you are doing. Also, for undergrad work, quite often calculators are flat not allowed on mathematics tests. If you want people to learn, you don't use a calculator to teach them, and you don't let them use a calculator to 'learn' it.

Imagine this situation: AP calc test, and your calculator breaks, and doesn't seem to want to work, after a little bit of messing. My solution to that exact situation was to put the calculator on the desk, and get the highest score possible (which was a 5, so I probably could afford to miss a few problems), though it took me a bit longer. After messing with it for a while after the exam, it finally reset. (Still no idea what happened, I actually didn't have any programs on it at that time.)

Having made a mostly arduino controlled mill that works, but needs work to correct some wobble (structure problem). I can tell you that even with the current set of shields, there isn't one that works out of the box. I had to modify the bipolar stepper on this page: http://www.tigoe.net/pcomp/code/circuits/motors/stepper-motors, to also accept an enable/disable. That's in addition to an Adafruit motor shield (which was when I was doing research on them, far and away the best). Both of which used two stacked chips in place of one.

So not *completely* custom, but it does need at least a modified circuit. Take another 5 people with slightly different knowledge and such, and you'd likely get different solutions, simply because there isn't one I've found which would work without modification. Even using a stock Adafruit motor shield, where you could power 4 DC motors, adding encoders to those would require custom work.

Multiple Arduinos wouldn't work well, as the inter-microcontroller communications are slow. I2C is limited to 400kbps, Serial was eliminated in my case (required to talk to the computer), and SPI might be fast enough, but at the time, there were only software implementations, which were slow. Arduino 0019 introduced a hardware library, so it may work now. (However, it wouldn't work with the shield noted above, as it uses pins 11 and 12)

Anything even mildly complicated probably requires it's own setup.

Here's an easier method:

grep -a -A 100 -B 100 $FUNCTION_NAME /dev/sdaX > recovery_blob

Adjust as needed

Actually, no Wine unfortunately does *NOT* register as Other, at least on the several systems I've used. I recently had to (prior to the latest steam survey) change the ID in Wine due to it bitching about w2k support ending. Other is likely mostly whatever people have hacked win2k to work(possibly some people with wine), and win2k8.

I've designed and built my own, and I must say that the rigidity part is very true. (Also, I now know why the particular design is favored, as it's more rigid) I must say that having not worked with wood for nearly 15 years, the quality of wood is crap. I did look it up and find out why. There was a change in the building standards (at least in the US), where instead of wood having to have 15% moisture content max when they left the mill, they now have to have 19% at the time of installation (meaning it likely leaves the mill at even higher than that.) This explains why the lumber seems a lot more warped now days.

If you can, spend the money for proper linear rails, I think they would be worth the investment. Using Steppers out of old Epson printers, I've got a theoretical (if it were rigid) level of ~8 micrometers/step. (Relatively small amounts of torque though)

Speaking as someone with an Alpha Station conveniently as a footrest...

I'm calling a double bullshit.
First of all the parent: 1.2GHz for 800 when Pentiums were 433MHz?
21164 Alphas, topped out at mostly 600MHz, and were faster than x86 clock for clock. They were also pushing the MHz limit at the time, being the first to 500MHz, and using a slightly later 533MHz (21164PC) they were damned fast compared to any x86 chip. As far as speed, at the time, they were overall the undisputed fastest processors. (DEC only made up to 8 processor machines as I recall. At least I think that's the limit for the 8400, a quick googling shows a reference to 12 processors, so it's likely higher)

21264 Alphas, were mostly released at under 800MHz, while air-cooled chips were demonstrated up to 1GHz, they weren't available. They were a lot faster per clock. (Of note, the Athlon used the EV6 (21264) bus which was one of the big reasons it did well. Plus a lot of DEC engineers going to AMD following the DEC/Compaq merger, which was if I recall correctly just before the 21264 was released, I don't recall any actual DEC hardware) Near the end P4s were released so you may be thinking 466MHz Alphas vs 1.2GHz P4s. (Where the Alphas would lose on integer, they would beat the P4s on floating point instructions) Benchmarking them, they were about 1.5x as fast clock for clock as at the time the fastest x86 processor (The original Athlon, mind you this is comparing optimized builds and the alpha didn't have SIMD instructions) If you were thinking of the API builds, you might be right, if you switch the MHz numbers around.

21364 Alphas were released following the HP merger and were the only ones which were over 1GHz. At this time, it was way late. The FPU was still respectable, but overall it was a case of too little too late. The 364 was not even a new core, it was a 264 wrapped in a much better communication to the outside world, on-board memory controller, and a very hypertransport like connection. (Which predated Hypertransport, at least in the beginning of the design, but was delayed so much, that as I recall Hammer wasn't that far off)

21464 was canceled, though it had a number of things, including the first Alpha SIMD instructions.

The alpha, even the 21064s, which were petering out in favor of 21164s when I got introduced to Alpha, were not cheap. However, they (21164PCs anyway) were priced comparably to a high end x86 system. When x86 got better and cheaper, they simply didn't keep up. Part of that was due to a DEC-Intel suit/resolution, which as far as I'm aware Intel didn't hold up. Which eventually got DEC merged with Compaq. Then it was all the 'Itanium is the future', where Compaq ended up basically killing Alpha for. When HP got it, they were also heavily in the Itanium camp. HP also had their own prior processor (PARISC) which was being killed off for Itanium. Which as I'm sure you are aware the Itanic future didn't turn out the be the case.

Second:
Slow, was the one thing the Alpha was not. Expensive, rare, hot and some other things, but slow it was not. Considering that an Alpha led the SPEC cpu benchmarks for over 9 *continuous* years, being broken of the integer by P4 on release, and fpu by a much later P4 (See above for how the Alpha's frequency wasn't keeping up on the 264s)

At no time, when alpha was being sold by DEC or Compaq, would SGI (MIPS) and Sun (SPARC) hardware have been faster per processor than Alpha. Look on the SpecCPU pages, or if you can find them (I can't) the old Seti@home statistics. Hell, look at just about *any* benchmark from around that time.

If that's so... where's my sense of security and government check?

For the second part: Remember we aren't talking about the US, UK, or most of Europe. We are talking about Kuwait, where there are different traditions.

Laws are different, because theoretically, we have a bunch of different sovereign nations.

To be fair usually it's "software patents are evil"

As far as patents being evil. They aren't inherently evil. Just that what is allowed to be patentable, is way more than the set of useful inventions. It may be to the point where the only way to make them actually promote ideas is, where we throw them all out because of abuses, and start with a much stricter set of rules. (Yes, that sucks for some people/companies)

I'm failing to see how an earthquake would destroy the crops in the midwest. Sure, there could be damage some farmers like having equipment destroyed and going bankrupt, but your scenario implies outright destruction of a fair portion of the midwest farms. (The US does have exports, Food being a big one.)

The only possibility I can think of that's even remotely like that is wholesale destruction of grain elevators.

They basically did add an x86 to Itanium. I think the Itanium 2 had an updated Pentium core on it, to improve the emulation speed. Frankly, though that took up a lot of die room, and was very slow.

Comparatively, I've seen x86 emulation be faster in many cases than native x86. Granted, this was with Alphas and fx!32, where the chip simply was faster. Trying that with a slower chip, much as Transmeta tried, didn't work so well. One of the problems with just using HT on AMD, is that there wasn't really a standard interface, and let's face it FPGAs are rare. FPGAs also require a design to run.

The thing that most people don't get is this: compilers are not magic. Special hardware almost always require special code. Code is relatively expensive/time-consuming to create. With compilers being unable to automagically generate great code (on of the major reasons for Itanium failing-Intel bet compilers would be a lot better than they were, or currently are) for even a VLIW as the IA-64 is, it basically killed any performance of Itanium. (Nevermind a lot of (at least from the outside) stupid design decisions, that got reversed when Intel brought in the HP engineers from PA-RISC & what remained of the Alpha engineers from DEC via Compaq, and produced the relatively much better Itanium 2.)

Now, as to why not differing architectures, it's hard. The hardware has to support it well, which can be done somewhat, the OS has to support it. Right now, there isn't a mainstream OS which is well setup to handle non-SMP multiprocessor. Usually if it does, that's only clockspeed differences, and maybe slightly different chips of the same architecture. (It was somewhat common on older SGI and Sun MP boxes.) Granted, Linux can be worked into doing cross-architecture MP (such as with IBM's RoadRunner), but it's not common and needs a lot of tweaking. You will note that there is only one RoadRunner system. Some of the Crays (also Linux) are that way as well. However, those are top10 level supercomputers, with a dedicated and usually very highly competent & trained staff. They would likely be useless without that staff. The only reason things like CUDA or OpenCL are useful is they are well defined interfaces, with a lot of hardware, and it doesn't really need to alter the Operating System.

For a custom piece of hardware, if it's deployed widely enough, it might be useful, see for example cell on the PS3, where you have a slightly different kind of semi-MP setup. Mostly older machines are coming to mind here for examples, some of them successful (PS2 emulation of PS1 via a chip which was usually used for sound) and the Nintendo DS, but most others have failed. Again, code is time-consuming, and unless you either have a very large base (DS/PS2) or a very specific reason(Supercomputers), you don't really want to deal with anything excessively complicated.

Indeed. If they are using it as swapspace, or something which writes very often to it, they could very easily wear it out in under a year, depending on the type of cells used, and how often it writes. (A few months is possible with very, very pessimistic assumptions about the cells, and assuming nearly constant writing.)

Granted, if they aren't idiots, they probably made sure it'd run at least 2 years without wierd usage patterns. In which case, the phones will probably be replaced, because pretty much anyone buying a Windows phone right now is either extremely susceptable to marketing and likely to buy a new latest and greatest phone, a tech looking at it for other reasons, or haven't read (m)any reviews on it.

So this may be a fairly small issue except to the techies, and a few unlucky people with odd usage patterns.