Thorough human history, and in all culture I'm aware of, there have always been midwives. Women who help other women, who learn from one another, watching the other women delivering babies, learning from mistakes and teaching each other.

So, no, I don't think not innately knowing how to deliver a baby is a big deal. At least nothing that changed in the last hundred years.

What has changed is our isolation from others. A hundred or two hundred years ago, you'd be hard pressed to live somewhere without some midwife nearby. Maybe if you lived alone on a farm (hard as there would always be family/farmhands around), but in this case the couple couldn't even call the neighbors for help, and they wouldn't be likely to know what to do.

Actually, I'm kind of surprised the midwife didn't stay on the phone to talk them through it. But yeah, google can substitute in a pinch. Kudos to the father for his level-headedness, many would've freaked out in that situation.

Group layers and a single window interface are in current SVN.

For everything else you'll have to wait a year or two until the Gimp developers integrate their new GEGL framework, revamping Gimp into something else entirely along the way. It'll use float-based RGB as its internal representation, but handle anything as input and output. The current implementation of GEGL is dog-slow though, so don't bother to try it.

As for the GP's suggestion for adjustment layers, no it's not enough. And yes, Adjustment layers could be implemented without waiting for GEGL integration, but the Gimp developers refuse to do it worrying that it'll make the integration harder (And because they want to come up with a completely new UI for them).

Shouldn't you be referencing the Space Carrier Blue Noah? (Thundersub for you I guess)

I mean, seriously. A sbumarine-aircraft carrier and nobody even mentions it???

Interestingly, I was looking at Sun's licensing and procedures. It turns out that they require a copyright assignment form to include your changes in the official version (like the FSF does, but the FSF is not a for profit company). Their procedure is for shared copyright with the author, but it gives them the right to do whatever they want with the code, regardless of license.

So, IBM would be buying the right to include all of the work in Sun's open source projects in their closed-sourced solutions and/or cannibalize them anyway they want. That's pretty big, really.

Granted, the current open source projects would survive, and IBM is nice enough to the open-source crowd that these won't be killed outright.

Then it sounds like you need a camera and GPS with bluetooth. They can talk to each other and fill in location data in real-time, and if you're in a studio or near your laptop, it can upload the pictures in the background.

You could even use it as a phone camera, or for videoconferencing, or whatever you want. Bluetooth is pretty standard for tethering like this.

Wifi is only useful if you want to upload directly to the internet. That's not always the best solution

Well, if you RTFA you'll find out that they did indeed put a bag in his bag, so he can carry while he carries, and even lay them flat so the TSA can check it while they check him.

Try out M-x make-frame-on-display

True interactive collaborative editing with all the Emacs tools for version control, TeX editing and everything else.

(Don't blame me, I found out about it here on slashdot)

GCC has supported PGO since at least 1999 (when I first saw it)

See if you can find some old docs and look up -pg, --profile-arcs, and related flags.

The amount and quality of optimization based on this information has varied over the years, but the basic infrastructure is pretty old. I think modern gccs build themselves with PGO by default.

I just wanted to point out that statically compiled code with PGO is even more advantageous because your final version is optimized with the runtime information, but doesn't have profiling code built in (which the java version would). So once again, static languages win.

Sorry, just tired of this stupid slashdot meme.

Also, GCC uses PGO for branch prediction. Instead of having the compiler guess which side of the branch gets taken more often, the profile gives you a better idea of the runtime behavior.

This can be useful for things like loop unrolling, branch prediction, inlining (is the increased code size worth it?), etc.

One example I remember is, if you know some branch is never taken (say, error handling), the compiler can put the normally taken branch right after the branch instruction, so the processor cache is more effective, and the untaken branch on an entirely different linker section, together with all the other similar branches of the application, so it's more easily paged out. The branch is still available to be executed if needed, of course, just a bit more slowly, but who cares?

This was back in 2003 or so, IIRC.

But then again, not all Buffalo buffalo buffalo Buffalo buffalo. After all if we assume a hierarchical buffalloes relation, there will be at least one buffalo at the bottom of the ladder. The one Buffalo buffalo who all Buffalo buffalo can buffalo, which would get buffalloed if it tried to buffalo other Buffalo buffalo.

Though it itheoretically possible that one Buffallo buffallo buffaloes a Buffalo buffalo that buffaloes a Buffalo Buffalo that Buffaloes the original Buffalo buffalo.

Who knows?

I'm still waiting for RoboCop.

At least as a guest in The Sarah Connor Chronicles....

From TFA:
The software: currently weâ(TM)re running a full install of Ubuntu Linux on the prototype with a custom Webkit browser.
Maybe they'll cut it down later, but I don't see why they should. They probably don't boot Gnome or any services, but it should be able to run random executables.

I wonder if they have tried to incorporate the setup from the 5 second boot project.