That's easy to fix. If a cell has not just the existing error correction codes but also digital ones as well, then mutagenic substances (of which there are a lot) and telemere shortening can be fixed. Well, once we've figured out how to modify the DNA in-situ. Nanotech should have that sorted soonish.

The existing error correction is neither very good nor very reliable. This is a good thing, because it allows evolution. You don't want good error correction between generations. You just want it in a single person over their lifespan, and you want it restricted so that it doesn't clash with retrotranspons and other similar mechanisms. So, basically, one whole inter-gene gap/one whole gene protected by one code. Doable. You still need cell death - intercept the signal and use a guaranteed method.

Here, in the year Lemon Meringue, we decided to solve the problem once and for all.

Instead of trying to kill cancer, we hijack its techniques. We start by having nanocomputers in the vaccuelles of each brain cell. These keep a continuous backup copy of the state of the brain up to death. Cancers disable the hard limit on cell duplication that cannot otherwise be avoided. By using the techniques of cell-devouring microphages, the cancer "consumes" the old cells and replaces them with new ones. They can't spread anywhere else, because that's how the cancer is designed to spread. Once the body has been fully replaced, the cancer is disabled. The brain is then programmed by the nanocomputers and the remaining cells are specialized by means of chemical signal.

This does result in oddly-shaped livers and three-handed software developers, but so far this has boosted productivity.

This is among the worst advice for programmers I've ever read. And it's pointless advice because it's where the majority of programmers already are.

Oh, I certainly agree that clever code is a bad idea, but you should never stop thinking creatively about how to make your code better. Focus it on finding ways to structure your code that are elegantly simple and obvious, on finding the perfect name for that variable, function or class, one that precisely captures the meaning and intent -- and if there is no such perfect name, focus it on finding ways to refactor your code so that there is a perfect name. Programming -- done right -- is an inherently creative task, and the scope for beneficial creativity is vast.

This even applies at the micro level. It's almost always the case that any handful of lines of code that contains branching logic can be structured in several different ways. Take the time and try each of them! See which is most concise, which is most readable, which highlights one aspect of the logic flow or another... and then spend some time deciding which aspect will be most important for the next programmer to read it. Think about how you can write code a little bit differently to eliminate -- and visibly eliminate -- important classes of functional or security bugs.

One of the more important insights I received, after nearly 20 years as a professional programmer, was that comments are evil. Comments are a hack to work around the failure to write code which is sufficiently clear and expressive (note that I'm talking about inline comments, not comments used to generate documentation). When I find myself typing a comment, I step back and look for ways to improve naming, or refactor, until the comment is no longer necessary.

Those are just a few examples, there are many more. Programming, like any art, is a never-ending opportunity for learning and improvement, because perfection is unachievable. Doesn't mean you shouldn't try, though. I can already hear the complaints "But I don't have time for that crap, I have deadlines, and..." that's just another set of constraints to be optimized. When time is tight, I focus on simplifying and making absolutely sure that my code is bug-free and has thorough automated tests, because there isn't any time for extended debugging.

Never, ever settle for mediocrity. One of my proudest days was when another programmer whose skills and code I highly respect called my code the cleanest and clearest he's ever read. I strive to impress my colleagues (and I work with some of the best) with clarity, simplicity and elegance. Sometimes I succeed, mostly I fail... but I always learn in the process. After 25 years, I think I'm learning more every day now than I did when I started. The lessons are more subtle and far less obvious, but I think they're more valuable.

No, we absolutely had it. We were being attacked by other nations such as China manipulating their money against the dollar. So, we forced it further.

Regardless of the role of skepticism, everybody seems to be overlooking one key point:

If this paper were to turn out to be correct, current climate models are useless and will need to be completely reworked. Well, maybe not completely. Some more than others. But it would contradict some of the fundamental assumptions of most of those models.

You obviously do not realize. In this case, they do not have footings on those. Just a base. As such, they can do that elsewhere and bring it in via truck (have to reach the area via car, so, it is right on a parking lot). Taking this approach, they can cut the time needed in half, and possibly the money.

The free market didn't provide alternatives. The free market created Microsoft and the other monopolies. Adam Smith warned against a free market.

The majority do not create alternatives, either. The majority like things to not change. The familiar will always better the superior in the marketplace.

Alternatives are created by small groups of people being disreputable, commercially unproductive and at total odds with the consumer. These alternatives will typically take 7-14 years to develop. Adoption will typically reach peak after another 7-14 years. By the 30th year after first concept, the idea will be "obvious" and its destiny an "inevitable consequence" of how things are done.

In reality, it takes exceptional courage and a total disregard for "how things are done". 7-14 years with guaranteed losses is not how the marketplace works. Even thinking along those lines is often met with derision and calls of "Socialism!" by the market. No, real inventors are the enemy of the free market.

If you want a Linux desktop, you must forgo all dreams of wealth. You must subject yourself to the abject poverty that is the lot of an inventor in a market economy, or move to somewhere that supports the real achievers.

Fred Brooks correctly pointed out that if you have a small development team (something like 20 or less), then pretty near any development methodology can work, if the team is good. Waterfall? That can be done. Extreme? Sure. Everyone work from home and email each other when they need something? Yup.

The problem is corruption. OSDL were working on a Linux desktop environment, but a key (financial) figure in the organization worked hard to kill off success and left around the time the unit went bankrupt. Several organizations they've been linked to have either gone belly up or have suffered catastrophic failure.

I won't name names, no point. What is the point is that such people exist in the Linux community at all, parasites that destroy good engineering and good work for some personal benefit of their own.

X is not great, but it's just a specification. People have developed Postscript-based GUIs using it. It's merely an API that you can implement as you like (someone ported it to Java) and extend as you like (Sun did that all the time). The reference implementation is just that. Interoperability of just that set of functions used by Glib/Gtk and Qt would give you almost all the key software.

Alternatively, write a GUI that has a port of those three libraries. You could use Berlin as a starting point, or build off Linux framebuffers, or perhaps use SDL, or write something unique. If it supports software needing those libraries, then almost everything in actual use will be usable and almost everything written around X in the future will also be usable. If what you write is better than X, people will switch.

I know you're just smacking down a troll, but climate models have been over-estimating warming for years, as demonstrated by this science.

That's not to say that climate models are bad science, they are good science investigating the nature of the earth; but people who put too much faith in them without evidence were performing bad science.

OK, I am down on climate models, because they have poor accuracy, but come on, they don't ignore the oceans in their models. Check it out on Wikipedia at least before writing something.

You might be able to say that their handling of the oceans is incorrect, and if you have a good reason, such a post would be interesting, but scientists definitely aren't ignoring the oceans in their models, I don't even know why you would think that.

Binary drivers exist and are loadable so long as they are properly versioned.

Block drivers can always use FUSE.

Automatic builders can recompile a shim layer with new kernels (or even the git tree version), automatic test harnesses or a repurposed Linux Test Project can validate the shim. You don't need to validate the driver for everykernel, if it's totally isolated from the OS and worked before then it'll remain working.

Automated distributors can then place the binaries in a corporate yum/apt repository.

What has an ABI got to do with it? Only gets in the way of writing clean code.

The commands to the bus don't change.
The commands sent to the hardware don't change.
The internal logic won't change.

That leaves the specific hooks to the OS and the externally visible structures.

Nobody is insane enough to use globals directly and structures are subject to change without notice. So external stuff will already be isolated.

If the hardware is available for any two of HyperTransport, PCI Express 2.x, VME/VXI or one of the low-power busses used on mobile hand-warmers, err, smart devices, then the actual calls to the bus hardware will be compartmentalized or go through an OS-based abstraction layer.

So 95% of a well-written driver is OS-agnostic and the remaining 5% is already is isolated.

So either drivers are very badly written (which is a crime against sanity) or the hardware vendor could place the OS-dependent code in its own DLL at bugger-all cost to them. Since the OS-dependent code has nothing trade secret in it, they can publish the source for the shim at no risk. Since the shim isn't the driver, there's no implication of support for OS' they don't know or understand. It's not their problem what the shim is used for.

Everyone's happy. Well, happier. The companies don't get harassed, the Linux users get their drivers, Microsoft gets fewer complaints about badly-written drivers killing their software. It's not open, it's not supported, but it's good enough.

He's right, though. Could be a form of epilepsy. Should get her checked by a real doctor.

A deep evolutionary pathway "gets it", dude. Like a bridge to nowhere, it goes its own way. Not like those shallow evolutionary pathways that just want to converge. I hate those guys!