Apple no longer makes computers that have optical drives. How long do you think it will be before the rest of the industry follows suit?

(Those who need them can of course still connect external optical drives.)

I'm being forced to learn Python.

If you're not intending to make any profit from it, then you can set up a company that has no assets to distribute the app. This will cost you a small amount, but it means that the patent troll can take the company to court if they want, but it will cost them money and the company will just declare bankruptcy without attending court and they won't be able to recoup their legal fees.

It's harder to covertly insert a backdoor into an open source client because people can watch the changes. It's much easier to insert it before it's open sourced, because then people have to review the entire code drop at once. That said, adding a back door into OpenSSL would be comparatively easy because no one understands the convoluted twisty maze of code paths in it.

Full homomorphic encryption is really hard. Homomorphic encryption allows you to encrypt your data, do some computation on the result, and then perform some operation on the output to get the same result as doing the operation on the unencrypted data. Current solutions are at least a factor of 1000 slower than doing it on unencrypted data, but that's only for general case. There are ways of encrypting data that preserve certain properties so you can, for example, perform simple database operations on it in the encrypted form and only interpret the results if you hold the keys. The down side of these approaches is that they increase the size (effectively doubling it for every primitive operation that you want to support), but with storage becoming cheap they may become interesting...

Having a romantic breakup is a lifestyle choice (at least that's what the other poster is arguing), and you put it into the same category as mental illness.

Not sure how you did that calculation. iPlayer HD is 3.6-4Mb/s, which works out at around 5-8 hours for 10GB. Standard definition content is 0.7Mb/s, which works out at just under 32 hours in 10GB.

That's 56Kb/s if you've got a good line, but if you've got a line that can do 56Kb/s then you're probably also close enough to the exchange that you can get ADSL, and a cheap ADSL package will cost less than dial-up these days. If you're somewhere where you can't get ADSL, then the line quality is likely not going to give you more than 26.4Kb/s, which works out to under 3KB/s once you add in protocol overhead and 2-2.5 being more common.

Sounds pretty sensible then. I suspect, from what they say on the Apple site, that it's actually slightly more subtle than reducing the priority, as that alone wouldn't give the power savings that they claim. I would think that what they're actually doing is increasing the time between scheduling quanta for AppNap applications and tacking them on to the end of quanta for foreground apps so that the CPU doesn't get two wakeups.

You'd lose that bet. It was one of the first-generation Core 2 MacBook Pros (I waited to replace my G4 PowerBook until they came out with 64-bit ones, because I didn't think 32-bit support in OS X would be around for much longer).

You don't mention what version you ran. They fixed it in Parallels 3.

That's the exact opposite of my experience. The ticket about the random crashing had a lot of backtraces attached but silence from Parallels support staff. It was eventually closed once they fixed the bug, with a note saying 'Fixed in Parallels 3'. The cause of the bug was that they completely failed to read the Intel docs on how IPIs work and it only worked on Core 1 as a result of an implementation detail that was explicitly not guaranteed by Intel. After reading that, even if it had been a free upgrade, I wouldn't have been inclined to trust them with code in ring 0.

Sure, as long as you only ever have one screen DPI to deal with and only need to support a small number of font sizes and don't ever need to print. Of course things look better if you draw them for the exact output format that you're targeting.

Timer coalescing is nice, but it's not that new. iOS and Android have done it for a while and it's mostly useful on devices that spend a lot of their time asleep. App Nap looks a bit annoying: much of the time I have apps hidden behind others because they're doing something processor-intensive that won't be finished for a while, so I hope it correctly handles this case instead of just slowing them down unconditionally. If the app is well-written, then apps that aren't doing anything won't be doing idle processing and so they will be asleep anyway. Safari Power Saver sounds like the thing that the Android Browser does in 4.1, which is quite annoying as it optimises for minimising RAM usage at the expense of responsiveness. Hopefully Apple's implementation is better than Google's... Compressed Memory is another thing that's nice, but not exactly cutting edge and also very easy to get wrong.

I bought Parallels 2. It contained a bug in their handling of IPIs that caused host kernel panics on Core 2 processors (i.e. the processor that I'd bought to run it on). They eventually found the bug and fixed it... in Parallels 3. Their solution to the problem of selling me a product that was not fit for purpose was for me to give them more money. I switched to VirtualBox and will never give that company money again. VirtualBox lacks a few of the nice things in VMWare (in particular, it wires all of the VM's memory and doesn't do deduplication), but it's quite useable.

When I had a Voodoo 2, many of my friends had no 3d accelerator at all. A lot of them bought TNTs when they came out and then kept them until the GeForce 2MX was released (it was really cheap, but still gave performance on a par with the original GeForce, so was quite popular). Sure, it was possible to spend hundreds of pounds on graphics cards every year, but as someone who was a child at the start of this and a student at the end, I still managed to play the latest games (although not at the highest settings) without spending much on graphics cards.

The Voodoo Rush was released in 1997. The TNT2 in 1999, the GeForce 2MX in 2000 and GeForce 4200 in 2002. All of them are low-end parts except for the TNT2, and so that's one low-end GPU every 2 years. That's about the upgrade cycle that I remember for people who were active gamers. Certainly not spending hundreds of dollars every year on high-end GPUs, as the original poster claimed.

Spoken like someone who has never actually written code to display text. Sure, with monospaced bitmap fonts, this is an easy problem. For modern text, you start off with a set of bezier paths representing each glyph. That's fairly easy to render, and you can just start drawing each one to the right of the previous one. That will give you blurry characters with ugly spacing, but it's a start.

So how do you fix the blurriness? Now you need some hinting telling the renderer when it should try to snap lines to the nearest pixel rather than approximate it and just rely on antialiasing. Oh, and those hints have to work on every combination of point size for the font and pixel size for the display (and, ideally, for different sub-pixel layouts) and so they're heavily parameterised. Doesn't need to be quite Turing-complete yet, but you're getting very close to Lambda calculus, although you can get away without recursion.

But you still have spacing problems. Consider this trivial example: To. Now, in your naive approach, the left hand side of the o is the same distance from the right hand end of the cross-bar of the T. This distance will be the same as the distance between characters in nm. If you see this at the start of a word, like Tool, then it will look like there is more space between To than between oo or ol and that's ugly. So now you need some kerning hints that tell you how to tweak the spacing for each pair of letters, and these need to be parameterised over every pair of letters. For a simple ASCII font, that's 2^14 combinations, so you don't want to list them individually, you need to compute them.

And that's just very basic letter layout. On a typical window, you may have thousands of characters, which all need to be laid out correctly (and deterministically, so characters don't jump around on every redraw). And so this is on the fast path. Is it surprising that it ends up in the fast path?

Both Windows and *NIX have had serious exploits involving font rendering. X used to put FreeType in the X server (which ran as root), windows used to put an equivalent in the kernel. Both have resulted in vulnerabilities from documents that embed fonts. When you have something that's performance critical (slow text rendering translates to slow window updates, which directly translates to user-perceived slowness) and depends on user-provided data, it's not surprising that there are security holes. X11 now moves font rendering to the client (although, like Quartz, it composites the glyphs on the server), so a font exploit doesn't get you root, it just gets you arbitrary code execution in your current application, for example the web browser.