One user is reporting file corruption and nobody else can replicate it. That's no reason to hold up a release or worry at all.
Otoh, for a while I repeatedly got file corruption copying large ~10gb files on 9.04 from my ext3 filesystem to an SMB share. The hash would be wrong maybe 3/4th of the time after copying and doing an 'md5sum smb/thefile'. So we should stop using ext3 also? disable cifs?
Chances are in both cases it had nothing to do with the filesystem at all and was something else like flaky hardware.
That's why you do these kinds of experiments away from your home world. Then the observers on the home world see the observers on Mars Research Colony exploded/imploded/whatever and they don't do it again. It's only the observers that may die that would experience it as the universe 'conspiring' against their research.
But it explains why no aliens... we would only meet the ones that didn't experiment on their home world and in universes where we didn't either. That would be pretty slim odds. If you subscribe to the universe forking at every decision nonsense.
To me, netbooks should not be considered a netbook if the screen is larger than 8". Anything bigger and you're in portable laptop territory, regardless of processor speed.
For me the dimensions of the screen is not what makes is a netbook. What I consider a netbook is:
a) long battery life b) low heat c) low weight d) low cost e) 'small' meaning not heavy or thick or clunky.
The perfect 'netbook' for me would be 14" screen, 1-2 pounds, 10+ hour battery life, $300. The biggest problems I have with 'real' laptops is they weigh a lot, burn your legs, and you have to carefully monitor the battery basically using it plugged in most of the time. I like using my 1024x600 netbook more than any of the laptops I've used for these reasons, except that the screen is just too small.
OK, I can see why the buttons being outside the tab would make sense, but it doesn't make sense for the location bar to be outside the tab, as what it displays is unique for every tab.
There is no difference between those buttons and the location bar.
The location bar shows the URL field for the current tab. It also uses global state, for instance browsing on one tab adds completion entries to other tabs. Should it be outside the tab because completing is global and not specific to a particular tab? No, because what it displays and how it operates is irrelevant to where it should be located. What matters is what visual grouping the element belongs to, and this is not the tab because the presence of the element is not unique to a tab.
Take another example, an SVG editor. What buttons are active and what is displayed (font, color, etc) depends on which object is selected. Does each object get a separate Font text field floating within its bounding box just because the data varies per object? No, that would be madness. The location bar per tab is just a degenerate case of this, but the same principle applies that controls are shown at the outermost layer where the element is always present.
Lets also put it in another way. The purpose of a tab is to switch between different views. Suppose the bookmarks bar, buttons, and location take 20% of the window. With tabs at the top, switching tabs changes 80% of the tab's area, plus a little bit extra for the URL and possibly different button states. With tabs at the bottom, switching tabs changes 100% of the tab's area plus some extra areas.
In terms of visual appearance, tabs in Chrome "sort of" switch between different views, but not completely. How would you explain what changes when you select a different tab? "The web page part is completely different, the buttons change what they show, and the bookmarks bar and menu buttons are unchanged" vs "When you select a different tab its contents show a different web page". I think you can see which is conceptually simpler and makes the most sense of the two.
Tabs on top makes a sense... because the address bar, back button, forward button, refresh/stop buttons, and home button are all part of the current tab, rather than the browser as a whole.
A cardinal rule of good user interface design is that controls are always in the same place. When the buttons are part of a tab, they may move around, for instance if the tab bar is set to hide if it contains one tab, or if the tab bar can expand to multiple lines, or if it can be placed horizontally or vertically.
In a GUI, "part of" means what visual grouping it belongs to and not the conceptual grouping it belongs to. If all the tabs contain the same controls, in the same positions, then these controls are not "part of" the tabs, they are part of something outside the tabs (they are factored out). To put it in geek terms, consider these expressions:
chrome: (xa + xb + xc) firefox: x(a + b + c)
Do you argue that "x" must be inside the grouping because it is 'part of' each term, even though it is the same for all terms? It's more clear and more usable to factor out everything that is shared in common.
Actually if Stephen Wolfram turns out to be correct then his ego must be defined by Rule 110 which, as has already been proven, is universal; it expands forever and is full of hot gasses.
I think these three are very different cases, and afaik (not much) only the first has been ruled out. Just because the second and third may be 'the same' for some particular experiment doesn't mean they are in fact the same. For instance, what happens when "self.last_observed_by.self != self" (ie one particle interacted with something else and the other didn't). Is there no interaction in either direction, or is there a interaction in just one direction, or is there a different kind of interaction?
But one thing about running Windows that has always been a complaint and that's it's estimation for "time remaining."
That's why you use a watt meter like Kill-A-Watt to measure the actual power draw. For me, on ASUS 1000HE, Linux was drawing about 2 watts more (limited resolution of KaW) when idle because it wasn't set up to lower the bus speed (it was using speedstep to change the CPU freq though)... that represents about 20-30% less idle battery life. Once I installed a kernel driver I found floating around on the net on some random site I got similar power use from Linux... but it was still harder to use (for instance it didn't start at boot).
So if you have linux doing the same power saving tricks as windows, you get better lifetime from linux. The problem is getting it all configured to do this.
Yes, it's called hardware level paging... The problem is from how the exceptional condition (null pointer access) is handled by the kernel, and not the fact that NULL was called.
No, it's not. The problem is that the kernel also has access to the process's memory, so if the process mapped page 0 as r-x then the kernel also has that page. So when the kernel jumps to NULL through a function pointer, it runs whatever code the process put there.
This mapping is done for efficiency because otherwise any system call would flush TLB at least *twice* and it would be slow as hell.
Hardware memory protection is as old as dirt, but it's also a brutish fossil, symbolic of a decayed era, gratefully forgotten.
In normal configs, Linux is vulnerable to this kind of problem by design because it runs unsafe programs and then for efficiency the kernel also has direct access to it's memory plus the memory for a process doing a syscall. And it's not just a NULL pointer, and preventing maps for page zero doesn't solve the problem... it just means you need to find a bug where you can corrupt a function pointer to point to mappable space.
What this demonstrates is that the cost of isolating programs from each other by using separate memory spaces has a much higher cost than commonly understood. It either has a ~10%-20% overhead and is insecure by design (kernel map includes calling process memory space) -or- it is far slower than even that, but safe (kernel memory is completely separate from process). Computers are already faster than many users need... maybe it's finally time for an OS with a single memory space, like JavaOS or jxos, or even Singularity.
One option to hide well the existence of encription software and data could be to put them among game files.
But this doesn't help you at all, because if they find this out then they know you've gone to extraordinary lengths to hide the data and the presence of the data. Which is even worse for you than just having truecrypt installed 'but I never used it'.
A real solution: a p2p distributed backup system. You store 10g of other people's data in exchange for 'free' distributed backup of 1g of your data (numbers made up). This would require strong encryption, and could also be widely popular or if nothing else explainable. This software could have a small feature where you could store a few of your own files into the local cache (the 10g part). So by entering a special extra password, you can retrieve the truecrypt or stenocrypt program or even the encrypted container file itself... this would be like 100 lines of code max on top of this distributed backup system. Save from the 'hidden backup' to ram disk and run from there, so it isn't saved to disk (disable swap).
Is ultimately a fad. I do not see any real utility in giving control of my software and security to a third party company.
Back in the day, computers were rare so you had one computer. Now an average person may have a smart cell phone, a home desktop computer, a laptop, a car, and a work computer that they want to access their data from. Google is betting the people want to seamlessly access their same data and programs on all of them at once. Which seems like a pretty good bet. So they try to make a chrome os, gears, etc to lock you in to their cloud.
On the other hand, a tiny bluetooth USB-like flash device the size of a quarter could do all of that, while having people feel like their data was under their control. Do you ever change any of this 'shared' data when you aren't physically present near the device that's changing it? A tiny 'personal cloud' device for personal data could get rid of the main reason for the cloud in the first place, having your data available everywhere. Without being locked-in to a google chrome or google gears (or whatever), google would have no advantage.
For that matter it wouldn't even need to have a large memory. It could use the device (phone, computer, etc) to fetch encrypted blocks from the internet (your home computer, or a service), so it might only store a cache of recently used data. And this would require very little power, so wireless power transfer could actually be feasible for keeping it charged.
...it makes you smack yourself on the head and go "why hasn't everybody been doing this for years?".... It seems so obvious that you could apply a transform,patch,reverse process... but only when pointed out and demonstrated.
Basically google created a big custom 'transform' that applies only to x86 exe files. The reason why this is a boring story and why nobody has done this before is because nobody has found a generic, simple way to do this. And they still haven't.
If google had actually created a 'new binary diffing algorithm' instead of a specific hack, and this worked for most binary files that have similarities that would be newsworthy. For instance if it could out of the box create small diffs for.exe,.doc,.xls,.ttf,.3ds,... that would be something.
From just poking around the web with gecko and webkit browsers I found a bunch of pages that looked fine rendered by gecko, but had elements in the wrong place or other visual problems rendered with webkit. The majority of sites render fine in both, but not all and other then acid tests I haven't visited any that rendered better in webkit.
I'd rather have the page look good than be super fast, so I'll stick with firefox until sites render as well in webkit or firefox becomes unusable slow.
My guess is Mozilla uses/GL option for visual c++ to do whole program optimization (if not, they should). Afaik this is currently not possible in gcc for C++ code except by cat'ing or #including all your files together into one.
In something huge like firefox there are probably a bunch of accessors and small functions that can be inlined to make a smaller *and* faster binary, if only the compiler can see the method implementation.
The important line from the article: "Theora uses 1600kbps, or about 60% more bandwidth than Mpeg-4 to reach about the same quality."
I had to use the direct links, but noticed that the ogg version was 10% taller but the same contents. A skewing like this could easily explain bad perceived quality, did anybody else notice this or it is just my Firefox 3.5 beta on linux that's messed up?
In general, it is accepted wisdom that Java has 1) a better optimizing JIT; and 2) a more advanced GC. In practice, however,.NET often ends up being faster, simply because the languages and the platform itself offer more optimization opportunities.
Java has a significantly better JIT and GC than CLR. Also CLR has actually significantly fewer optimization opportunities than JVM due to interaction of some of the features it has ('real' generics, value types, bytecode instructions). That's why the last known information has CLR only inlining one method at a time, if it doesn't cross assemblies, and isn't called through an interface, and it is less that 32 instructions long and contains no branches. Think about that. As inlining goes that's pathetically bad, and the reason is that the complexity explodes if they inline deeper. That precludes a whole host of optimizations.
For example,.NET has value types, and standard class library uses them a lot - and they are obviously more efficient for specific cases. For Java to match this, it has to do escape analysis to determine where heap-allocated reference types are effectively used as if they were value types. Other examples include all methods in Java being virtual by default (whereas it's opt-in in.NET).
Virtual methods are 'final' to the JVM until a class is loaded that overrides them. They have zero performance impact to a program. There's an interview with Andjers Heilsberg (lead language designer) where he doesn't even know this, so this is a common ignorance among C# developers. It also shows how absurd some of the design decisions were, that he cites performance as a reason for this.
Value types can be faster, but this is a difference not an optimization. The reality is that value types (and the differences in the bytecode operations) cause an overall general slowness to CLR that affects everything. Then you throw in covariant+contravariant, generics, and other 'features' and you end up with a system that is prohibitively difficult to optimize. Value types are convenient for not having to manually write specialized classes, but that's the limit to their value. If you specialize the classes in Java you end up with better performance (but this is often not practical).
Java does escape analysis because it can do it. For instance take this quote from one of the Sun developers working on invokedynamic implementation:
One reason for this difference in approach is that the Microsoft CLR JIT does not appear to be under active development; its optimization level is as rudimentary as the earliest Java JITs. In the CLR that kind of performance is just the accepted cost of running managed code.... While IronPython on the DLR has to do hard, brilliant work to "iron" out the wrinkles in the CLR JIT's weak performance profile, the "irony" is that Hotspot has already been optimizing highly dynamic programs for almost a decade.
... that's before invokedynamic.
Language-wise, both platforms are doing pretty well. For comparison with your list,.NET has IronPython (which is in fact more up-to-date than Jython), IronRuby (which is still in alpha and generally less stable than JRuby), F#, and Boo.
These pale in comparison to the languages that compile to JVM, in terms of performance, interoperability, and popularity.
Furthermore, Mono is way ahead of languages like Java in that regard because, unlike Java, Mono is based on an open standard and there are no known patents on the language core or core libraries.
Java is based on an open standard... the fully open-source reference JDK.
The reference JVM is also significantly faster than mono and somewhat faster than Microsoft CLR and has loads of somewhat useful other languages implementations that compile to it (Ruby, Python, Scala, Groovy, etc). So I'm not sure where you're pulling "way ahead" from.
What's going on here is that the vast majority of computer software is crap. And if the programmers think that nobody is ever going to see the source and that it will be impossible to verify the results then the software they write is even crappier. And even if it were traced back to the incompetent programmers there'd be no liability for them... worst cases they get fired and go to work at some other company that doesn't know better than to hire them.
Of course there's also the purposely rigged voting software... but that's not going to add 5k votes, it's just going to change them.
In fact, the best is moving with the flow of traffic. If traffic is going 85, and you are doing 65, guess what? You are now a rolling road block, and causing an unsafe situation as all the rest of the traffic has to adjust to you.
In my experience, a huge number of traffic accidents at highway speed are caused by mechanical failures or deer. Neither of which you can usually do jack about anyway (deer are invisible) and a difference between hitting a deer at 65 vs 85 is HUGE.
Frankly I don't give a damn if most other drivers are creating an unsafe situation by driving much faster than a safe speed, causing congestion as they catch up to drivers going a reasonable speed. After several experiences with deer I'll take a safer actual speed over a safer relative speed any day.
Most of he ones I have hit full brightness pretty much immediately.
1) How much did you pay for them 2) Where did you buy them 3) What does "pretty much" immediately mean
People always say 'oh my CFLs start instantly and were dirt cheap and lasted forever'. Then it turns out instantly is a minute, dirt cheap is $10 a bulb, and 'forever' is at 10 minutes a day.
This is what happens when all your engineers are too smart... they build things for their level of skill, and then when something goes wrong there's nobody even smarter to call in to fix it.
In this case, google builds this fantastically complicated yet simple global filesystem and series of interdependent services that make up their search and apps. Then something goes wrong like say their enormous bandwidth temporarily exceeded by a site backup (or whatever) and dominoes start falling all over each others.
The problem is that programming a libc is the worst kind of programming... you have to be compatible with N different standards that are incompatible with each other. A lot of the functions you have to implement are impossible to simultaneously be correct and not make you puke (see printf). And on top of that, nobody even cares since they're all using some high-level library to call your libc functions anyway.
I really wish somebody would come out with a decent libc for linux though. With glibc, you either compile statically and have a 1+mb binary that's still dynamically linked anyway because you used a socket or your program just doesn't run on some systems and you have dll hell far worse than on any Windows. If you've ever had to deliver a non-OSS binary for linux you know what I'm talking about.
Dietlibc is the most convenient alternative by far, but it has several bugs, is slow, and errno is not threadsafe. For instance printf("%2d\n", 222) prints nothing. But if you test your software you can use it really easily, just CC="diet gcc". The uClibc is better, but it's a pita to use, requiring its own entire toolchain.
Since nobody actually pays for developers to work on libc, you end you with whoever crazy people will actually work on it. So while the fork is a good thing, it's probably just going to be more of the same.
Slashdot Mirror
One user is reporting file corruption and nobody else can replicate it. That's no reason to hold up a release or worry at all.
Otoh, for a while I repeatedly got file corruption copying large ~10gb files on 9.04 from my ext3 filesystem to an SMB share. The hash would be wrong maybe 3/4th of the time after copying and doing an 'md5sum smb/thefile'. So we should stop using ext3 also? disable cifs?
Chances are in both cases it had nothing to do with the filesystem at all and was something else like flaky hardware.
That's why you do these kinds of experiments away from your home world. Then the observers on the home world see the observers on Mars Research Colony exploded/imploded/whatever and they don't do it again. It's only the observers that may die that would experience it as the universe 'conspiring' against their research.
But it explains why no aliens... we would only meet the ones that didn't experiment on their home world and in universes where we didn't either. That would be pretty slim odds. If you subscribe to the universe forking at every decision nonsense.
To me, netbooks should not be considered a netbook if the screen is larger than 8". Anything bigger and you're in portable laptop territory, regardless of processor speed.
For me the dimensions of the screen is not what makes is a netbook. What I consider a netbook is:
a) long battery life
b) low heat
c) low weight
d) low cost
e) 'small' meaning not heavy or thick or clunky.
The perfect 'netbook' for me would be 14" screen, 1-2 pounds, 10+ hour battery life, $300. The biggest problems I have with 'real' laptops is they weigh a lot, burn your legs, and you have to carefully monitor the battery basically using it plugged in most of the time. I like using my 1024x600 netbook more than any of the laptops I've used for these reasons, except that the screen is just too small.
OK, I can see why the buttons being outside the tab would make sense, but it doesn't make sense for the location bar to be outside the tab, as what it displays is unique for every tab.
There is no difference between those buttons and the location bar.
The location bar shows the URL field for the current tab. It also uses global state, for instance browsing on one tab adds completion entries to other tabs. Should it be outside the tab because completing is global and not specific to a particular tab? No, because what it displays and how it operates is irrelevant to where it should be located. What matters is what visual grouping the element belongs to, and this is not the tab because the presence of the element is not unique to a tab.
Take another example, an SVG editor. What buttons are active and what is displayed (font, color, etc) depends on which object is selected. Does each object get a separate Font text field floating within its bounding box just because the data varies per object? No, that would be madness. The location bar per tab is just a degenerate case of this, but the same principle applies that controls are shown at the outermost layer where the element is always present.
Lets also put it in another way. The purpose of a tab is to switch between different views. Suppose the bookmarks bar, buttons, and location take 20% of the window. With tabs at the top, switching tabs changes 80% of the tab's area, plus a little bit extra for the URL and possibly different button states. With tabs at the bottom, switching tabs changes 100% of the tab's area plus some extra areas.
In terms of visual appearance, tabs in Chrome "sort of" switch between different views, but not completely. How would you explain what changes when you select a different tab? "The web page part is completely different, the buttons change what they show, and the bookmarks bar and menu buttons are unchanged" vs "When you select a different tab its contents show a different web page". I think you can see which is conceptually simpler and makes the most sense of the two.
Tabs on top makes a sense ... because the address bar, back button, forward button, refresh/stop buttons, and home button are all part of the current tab, rather than the browser as a whole.
A cardinal rule of good user interface design is that controls are always in the same place. When the buttons are part of a tab, they may move around, for instance if the tab bar is set to hide if it contains one tab, or if the tab bar can expand to multiple lines, or if it can be placed horizontally or vertically.
In a GUI, "part of" means what visual grouping it belongs to and not the conceptual grouping it belongs to. If all the tabs contain the same controls, in the same positions, then these controls are not "part of" the tabs, they are part of something outside the tabs (they are factored out). To put it in geek terms, consider these expressions:
chrome: (xa + xb + xc)
firefox: x(a + b + c)
Do you argue that "x" must be inside the grouping because it is 'part of' each term, even though it is the same for all terms? It's more clear and more usable to factor out everything that is shared in common.
Actually if Stephen Wolfram turns out to be correct then his ego must be defined by Rule 110 which, as has already been proven, is universal; it expands forever and is full of hot gasses.
provided that state is "attached" to the entangled particles (that is, it's local).
A hidden variable:
return self.state;
A hidden variable controlled by another hidden variable:
self.state = self.last_observed_by->state;
return self.state;
An entangled variable that isn't known yet:
self.state = calc_state(self, self.last_observed_by);
return self.state;
I think these three are very different cases, and afaik (not much) only the first has been ruled out. Just because the second and third may be 'the same' for some particular experiment doesn't mean they are in fact the same. For instance, what happens when "self.last_observed_by.self != self" (ie one particle interacted with something else and the other didn't). Is there no interaction in either direction, or is there a interaction in just one direction, or is there a different kind of interaction?
But one thing about running Windows that has always been a complaint and that's it's estimation for "time remaining."
That's why you use a watt meter like Kill-A-Watt to measure the actual power draw. For me, on ASUS 1000HE, Linux was drawing about 2 watts more (limited resolution of KaW) when idle because it wasn't set up to lower the bus speed (it was using speedstep to change the CPU freq though)... that represents about 20-30% less idle battery life. Once I installed a kernel driver I found floating around on the net on some random site I got similar power use from Linux... but it was still harder to use (for instance it didn't start at boot).
So if you have linux doing the same power saving tricks as windows, you get better lifetime from linux. The problem is getting it all configured to do this.
Yes, it's called hardware level paging ... The problem is from how the exceptional condition (null pointer access) is handled by the kernel, and not the fact that NULL was called.
No, it's not. The problem is that the kernel also has access to the process's memory, so if the process mapped page 0 as r-x then the kernel also has that page. So when the kernel jumps to NULL through a function pointer, it runs whatever code the process put there.
This mapping is done for efficiency because otherwise any system call would flush TLB at least *twice* and it would be slow as hell.
Hardware memory protection is as old as dirt, but it's also a brutish fossil, symbolic of a decayed era, gratefully forgotten.
In normal configs, Linux is vulnerable to this kind of problem by design because it runs unsafe programs and then for efficiency the kernel also has direct access to it's memory plus the memory for a process doing a syscall. And it's not just a NULL pointer, and preventing maps for page zero doesn't solve the problem... it just means you need to find a bug where you can corrupt a function pointer to point to mappable space.
What this demonstrates is that the cost of isolating programs from each other by using separate memory spaces has a much higher cost than commonly understood. It either has a ~10%-20% overhead and is insecure by design (kernel map includes calling process memory space) -or- it is far slower than even that, but safe (kernel memory is completely separate from process). Computers are already faster than many users need... maybe it's finally time for an OS with a single memory space, like JavaOS or jxos, or even Singularity.
One option to hide well the existence of encription software and data could be to put them among game files.
But this doesn't help you at all, because if they find this out then they know you've gone to extraordinary lengths to hide the data and the presence of the data. Which is even worse for you than just having truecrypt installed 'but I never used it'.
A real solution: a p2p distributed backup system. You store 10g of other people's data in exchange for 'free' distributed backup of 1g of your data (numbers made up). This would require strong encryption, and could also be widely popular or if nothing else explainable. This software could have a small feature where you could store a few of your own files into the local cache (the 10g part). So by entering a special extra password, you can retrieve the truecrypt or stenocrypt program or even the encrypted container file itself... this would be like 100 lines of code max on top of this distributed backup system. Save from the 'hidden backup' to ram disk and run from there, so it isn't saved to disk (disable swap).
Is ultimately a fad. I do not see any real utility in giving control of my software and security to a third party company.
Back in the day, computers were rare so you had one computer. Now an average person may have a smart cell phone, a home desktop computer, a laptop, a car, and a work computer that they want to access their data from. Google is betting the people want to seamlessly access their same data and programs on all of them at once. Which seems like a pretty good bet. So they try to make a chrome os, gears, etc to lock you in to their cloud.
On the other hand, a tiny bluetooth USB-like flash device the size of a quarter could do all of that, while having people feel like their data was under their control. Do you ever change any of this 'shared' data when you aren't physically present near the device that's changing it? A tiny 'personal cloud' device for personal data could get rid of the main reason for the cloud in the first place, having your data available everywhere. Without being locked-in to a google chrome or google gears (or whatever), google would have no advantage.
For that matter it wouldn't even need to have a large memory. It could use the device (phone, computer, etc) to fetch encrypted blocks from the internet (your home computer, or a service), so it might only store a cache of recently used data. And this would require very little power, so wireless power transfer could actually be feasible for keeping it charged.
...it makes you smack yourself on the head and go "why hasn't everybody been doing this for years?". ... It seems so obvious that you could apply a transform,patch,reverse process... but only when pointed out and demonstrated.
Basically google created a big custom 'transform' that applies only to x86 exe files. The reason why this is a boring story and why nobody has done this before is because nobody has found a generic, simple way to do this. And they still haven't.
If google had actually created a 'new binary diffing algorithm' instead of a specific hack, and this worked for most binary files that have similarities that would be newsworthy. For instance if it could out of the box create small diffs for .exe, .doc, .xls, .ttf, .3ds, ... that would be something.
From just poking around the web with gecko and webkit browsers I found a bunch of pages that looked fine rendered by gecko, but had elements in the wrong place or other visual problems rendered with webkit. The majority of sites render fine in both, but not all and other then acid tests I haven't visited any that rendered better in webkit.
I'd rather have the page look good than be super fast, so I'll stick with firefox until sites render as well in webkit or firefox becomes unusable slow.
I bet multi-modal reflection sorting can determine what the confidential info is.
My guess is Mozilla uses /GL option for visual c++ to do whole program optimization (if not, they should). Afaik this is currently not possible in gcc for C++ code except by cat'ing or #including all your files together into one.
In something huge like firefox there are probably a bunch of accessors and small functions that can be inlined to make a smaller *and* faster binary, if only the compiler can see the method implementation.
The important line from the article: "Theora uses 1600kbps, or about 60% more bandwidth than Mpeg-4 to reach about the same quality."
I had to use the direct links, but noticed that the ogg version was 10% taller but the same contents. A skewing like this could easily explain bad perceived quality, did anybody else notice this or it is just my Firefox 3.5 beta on linux that's messed up?
In general, it is accepted wisdom that Java has 1) a better optimizing JIT; and 2) a more advanced GC. In practice, however, .NET often ends up being faster, simply because the languages and the platform itself offer more optimization opportunities.
Java has a significantly better JIT and GC than CLR. Also CLR has actually significantly fewer optimization opportunities than JVM due to interaction of some of the features it has ('real' generics, value types, bytecode instructions). That's why the last known information has CLR only inlining one method at a time, if it doesn't cross assemblies, and isn't called through an interface, and it is less that 32 instructions long and contains no branches. Think about that. As inlining goes that's pathetically bad, and the reason is that the complexity explodes if they inline deeper. That precludes a whole host of optimizations.
For example, .NET has value types, and standard class library uses them a lot - and they are obviously more efficient for specific cases. For Java to match this, it has to do escape analysis to determine where heap-allocated reference types are effectively used as if they were value types. Other examples include all methods in Java being virtual by default (whereas it's opt-in in .NET).
Virtual methods are 'final' to the JVM until a class is loaded that overrides them. They have zero performance impact to a program. There's an interview with Andjers Heilsberg (lead language designer) where he doesn't even know this, so this is a common ignorance among C# developers. It also shows how absurd some of the design decisions were, that he cites performance as a reason for this.
Value types can be faster, but this is a difference not an optimization. The reality is that value types (and the differences in the bytecode operations) cause an overall general slowness to CLR that affects everything. Then you throw in covariant+contravariant, generics, and other 'features' and you end up with a system that is prohibitively difficult to optimize. Value types are convenient for not having to manually write specialized classes, but that's the limit to their value. If you specialize the classes in Java you end up with better performance (but this is often not practical).
Java does escape analysis because it can do it. For instance take this quote from one of the Sun developers working on invokedynamic implementation:
One reason for this difference in approach is that the Microsoft CLR JIT does not appear to be under active development; its optimization level is as rudimentary as the earliest Java JITs. In the CLR that kind of performance is just the accepted cost of running managed code. ... While IronPython on the DLR has to do hard, brilliant work to "iron" out the wrinkles in the CLR JIT's weak performance profile, the "irony" is that Hotspot has already been optimizing highly dynamic programs for almost a decade.
... that's before invokedynamic.
Language-wise, both platforms are doing pretty well. For comparison with your list, .NET has IronPython (which is in fact more up-to-date than Jython), IronRuby (which is still in alpha and generally less stable than JRuby), F#, and Boo.
These pale in comparison to the languages that compile to JVM, in terms of performance, interoperability, and popularity.
Furthermore, Mono is way ahead of languages like Java in that regard because, unlike Java, Mono is based on an open standard and there are no known patents on the language core or core libraries.
Java is based on an open standard... the fully open-source reference JDK.
The reference JVM is also significantly faster than mono and somewhat faster than Microsoft CLR and has loads of somewhat useful other languages implementations that compile to it (Ruby, Python, Scala, Groovy, etc). So I'm not sure where you're pulling "way ahead" from.
Probably more like:
int ok = validate_ballot(); // gotta have a goto
if (ok);
votes[candidate]++;
. . .
if (!ok)
goto screen1;
What's going on here?
What's going on here is that the vast majority of computer software is crap. And if the programmers think that nobody is ever going to see the source and that it will be impossible to verify the results then the software they write is even crappier. And even if it were traced back to the incompetent programmers there'd be no liability for them... worst cases they get fired and go to work at some other company that doesn't know better than to hire them.
Of course there's also the purposely rigged voting software... but that's not going to add 5k votes, it's just going to change them.
In fact, the best is moving with the flow of traffic. If traffic is going 85, and you are doing 65, guess what? You are now a rolling road block, and causing an unsafe situation as all the rest of the traffic has to adjust to you.
In my experience, a huge number of traffic accidents at highway speed are caused by mechanical failures or deer. Neither of which you can usually do jack about anyway (deer are invisible) and a difference between hitting a deer at 65 vs 85 is HUGE.
Frankly I don't give a damn if most other drivers are creating an unsafe situation by driving much faster than a safe speed, causing congestion as they catch up to drivers going a reasonable speed. After several experiences with deer I'll take a safer actual speed over a safer relative speed any day.
Most of he ones I have hit full brightness pretty much immediately.
1) How much did you pay for them
2) Where did you buy them
3) What does "pretty much" immediately mean
People always say 'oh my CFLs start instantly and were dirt cheap and lasted forever'. Then it turns out instantly is a minute, dirt cheap is $10 a bulb, and 'forever' is at 10 minutes a day.
This is what happens when all your engineers are too smart... they build things for their level of skill, and then when something goes wrong there's nobody even smarter to call in to fix it.
In this case, google builds this fantastically complicated yet simple global filesystem and series of interdependent services that make up their search and apps. Then something goes wrong like say their enormous bandwidth temporarily exceeded by a site backup (or whatever) and dominoes start falling all over each others.
The problem is that programming a libc is the worst kind of programming... you have to be compatible with N different standards that are incompatible with each other. A lot of the functions you have to implement are impossible to simultaneously be correct and not make you puke (see printf). And on top of that, nobody even cares since they're all using some high-level library to call your libc functions anyway.
I really wish somebody would come out with a decent libc for linux though. With glibc, you either compile statically and have a 1+mb binary that's still dynamically linked anyway because you used a socket or your program just doesn't run on some systems and you have dll hell far worse than on any Windows. If you've ever had to deliver a non-OSS binary for linux you know what I'm talking about.
Dietlibc is the most convenient alternative by far, but it has several bugs, is slow, and errno is not threadsafe. For instance printf("%2d\n", 222) prints nothing. But if you test your software you can use it really easily, just CC="diet gcc". The uClibc is better, but it's a pita to use, requiring its own entire toolchain.
Since nobody actually pays for developers to work on libc, you end you with whoever crazy people will actually work on it. So while the fork is a good thing, it's probably just going to be more of the same.