If you notice in the article, that's why there is a whole order-of-magnitude difference between the basic and the parameterized COCOMO estimations.

Using the parameterized models, you're able to describe a lot of the complexities that set kernel-programming apart.

Now, whether or not they're enough is a whole other topic, but the model DOES try to account for such differences. I have a feeling that the real-life-projects they used to generate their parameter coefficients included very few OSes.

It would be interesting to make a ceiling calculation of ACTUAL development time for the Linux kernel (something like, for each month of the kernel's life, the number of developers who submitted patches * 1MM). Would that at all approach the COCOMO number?

The problem is that the left-eye and right-eye imagines need to be separated. Unlike the the clumsy old red & blue method, both eye's images cannot exist in the same source image. Current systems use a *physical* difference between the two perspectives, whether it's polarity (common in theater systems) or timing (common in TV systems).

So the difference between 2D and 3D TVs is that the 3D TV must be able to make a physical difference between the two perspectivesThe most common system for this in 3D TVs now is to double the TV's refresh rate (to 120Hz), and alternate showing left eye then right-eye images. The viewer then has special shutter glasses, which are synchronized with the TV. They work by blocking the right eye when the left-eye image is displayed, and block the left-eye when the right-eye image is displayed.

Other technology, which is more costly on the TV side, but doesn't require such fancy glasses, is for the TV to interleave scan lines with different polarities. Then left-eye images are displayed only on the lines which are polarized one direction, while the right-eye images are displays only on the lines polarized the other direction. Then the viewer just needs the same, simple, polarized glasses as used in the movie theaters. But the image will effectively be half the resolution of the TV.

The Pirate Party's opposed? Gee, Microsoft MUST be shaking in their boots now.

This is DARPA... It's been a LONG time since they've ever actually paid for development through final production.

Their strategy is to pay for initial technology development and proofs of concept, and then encourage (and probably help) to find a government customer who actually wants a product based on those technologies.

So the timeframe for a real product winds up being much longer. And the final bill to the taxpayers, much higher.

The GPS receiver in both the 3G and 3GS does indeed work stand-alone. The assist servers merely provide faster time-to-fix by providing the data you mention.

Without a cell connection, both models will still eventually locate a satellite and obtain the almanac like any normal GPS device.

The A-GPS used by the 2G is subpar to true GPS.

The 3G and 3GS HAVE true GPS that maybe be operated standalone or assisted. Its accuracy is equal to most any other handheld GPS unit, and the assisted portion allows faster time-to-fix than standard products.

Which the 3G is missing that makes turn-by-turn difficult is a compass. Most turn-by-turn devices have a digital compass, which allows detecting that you've completed a turn an instaneous result. Without a compass, one has to depend on consecutive positioning calculations to detect that you are indeed moving in a different direction now (accumulating enough readings in the new direction to rule out precision error).

The 3GS DOES have the digital compass.

However, even in the 2G and 3G, one could use the accelerometer to confirm a turn. It requires using more than just CoreLocation in the apple SDK, but it's entirely doable and just as reliable an indicator as a digital compass.

I don't know if TomTom uses this approach in non-3GS devices or not, though. Some other apps do.

The conversion has absolutely nothing to do with cost of energy. They're calculating the amount of energy (measured in energy density units of gallons of gasoline) required to move the vehicle.

Basically, they're claiming the car requires 146Wh/mi for the somewhat arbitrary commute distance selected by the EPA. ((33705Wh/g)/(146Wh/mi)) = 230mpg (equivalent).

Granted, that works out to around 6kWh for a 40 mile commute.

This is windows. find == grep. Well, find < grep.

Well, technically... Easily. You can claim the lives themselves are invaluable, but the judgement against the offending company would most definitely have a very specific dollar figure.

The insurance is for that. Not to replace the people themselves.

Once touched by a classified process, the non-classified data becomes classified, until you painstakingly prove that it is not.

Oversight? Hardly. It's damned expensive to produce unclassified content from a classified source.

By default, it is assumed ALL data generated by a classified source is classified. To unclassify any of that information requires a highly-tested, bulletproof-design of software that can be shown that in the process of declassifying any part of the data, it is impossible that something classified accidently got in there.

It's much cheaper to just leave everything classified at the same level as the piece of hardware/algorithms that produced it.

In addition to the other commentaries:

Threading only applies to a subset of parallizable cases, on a subset of computing architectures.

You're not going to use threads to decompose a for loop doing simple non-dependent mathematic operations over a large vector. That's why the ugly vector operations were added to C for Alti-Vec/MMX/SSE/etc. It's another type of problem.

As long as software development is stuck in a cycle of having to invent new programming solutions for every new computing architecture, we're not going to see a whole lot of variance/advancement in computer architectures.

What is desperately being sought now is a much more generic way of indicating parralelism in code, that a compiler can then parralelize or no parallelize using any number of techniques, depending on the specific architecture it's compiling to.

People talk about fancy super-intelligent compilers, but that's not really what we're after now. They key is "merely" being able to concisely indicate data relationships (foremost dependency, but other attributes as well), which will open the door for any number of hardware and software innovations.