Really? Say there is some poisoned food, but you don't know that it is poisoned, and you are hungry. But someone else does.
According to your claim, that other person should not stop you from eating that stuff, because after all, you know best what is good for you.
OK, now you will say "ah, but that's just a lack of knowledge, if I knew what is in that food, I'd certainly decide not to eat it." So let's slightly modify the situation:
You know quite well that there's cyanide in the food, but you believe cyanide would be harmless. The other person knows quite well that cyanide will kill you. So should that other person still stop you?
OK, let's modify again: The person doesn't know that there's cyanide in the food, but only firmly believes it. Should she still prevent your from eating it?
OK, make another slight change: She doesn't believe that there's cyanide in the food, but she believes that God will throw you in hell if you eat that food. Should she still prevent you from eating it?
Now I'm pretty sure that in the first scenario you'd say "prevent" (thus violating your own rule), and in the last scenario you would say "not prevent". But where would you make the switch, and why?
Things are simply not as simple as you want them to make.
"Great" in this case means "non-GPL" (YMMV, of course).
That's a very strange definition of great. Virtually everyone relates that word to features, intuitiveness, absence of annoying bugs, etc. That is, to properties of the IDE.
And no, that's not a question of mileage, that's a question of proper use of the language.
But how can you define defmacro using defmacro before you have defined defmacro? (And afterwards, it wouldn't make sense because it already is defined).
If your speedometer shows a higher speed than your real one, then whenever you are too fast, your speedometer will be showing a too high speed, and therefore you cannot claim not to have known that you have been too fast. However I'm not so sure what the ruling would be if the speedometer shows a too low speed (and it's not your fault for either negligence in getting the car serviced or proven active manipulation, and you weren't so much over speed limit that you should have noticed it even without reading the speedometer).
That is compiler and platform-independent, so there's no need to make separate tools.
Actually, it's not completely platform independent. For example, does the following code produce undefined behaviour?
int i = 256; i = i*i;
On a 16 bit platform, it does. Of course, 16 bit platforms are basically obsolete (at least for desktop/server software; I'm not sure if there are embedded systems still using 16 bit architectures), and on 32 bit or 64 bit platforms, it will work fine.
To be honest, in this situation I would like the compiler to inform me that it had eliminated some code as it is probably not what I meant. Why not write it like this instead?
int foo(int a, unsigned int b) { a+=b; return a; }
Then in the calling code: int *a; unsigned int *b; *b=10; *a = foo(1,*b);
I understand that this is a simple example, but I prefer to write my code like this as it ensures that the pointers are only dereferenced within the scope in which they are declared.
I can tell you at least one reason why you wouldn't want to write the code you did: Your assignment to *b is undefined behaviour because you never initialized b.
I like even more the fact that, given that a diagnostic is sometimes required, but never disallowed, and the text of a diagnostic is not regulated, a conforming compiler may just output on every compilation:
While what you say is true, I think it's not what they mean. Instead what they mean is compilers taking advantage of undefined behaviour you didn't notice. The compiler is allowed to assume that undefined behaviour never happens, and optimize accordingly. The important point is that this can even affect code before the undefined behaviour would occur. For example, consider the following code, where undefined() is some code that causes undefined behaviour:
Now if a>4, the code inevitably runs into undefined behaviour, and therefore it may assume that a is not larger than 4 right from the start. Therefore it is allowed to compile the complete block to simply
big=false;
Note that even the assert doesn't help because the compiler "knows" it cannot trigger anyway, and therefore optimizes it out.
I think it is not hard to imagine how this can lead to security problems.
Another nice example (which I read on the gcc mailing list quite some time ago; not an exact quote though):
bool validate_passwd(char const* user) {
int tries = 0;
char const* given_passwd = ask_password();
char const* user_passwd = get_password(user);
while (strcmp(given_password, user_password))
{
tries = tries++;/* undefined behaviour! */
if (tries > 3)
return false;/* allow only to try three times */
printf("password not valid. Please try again.\n");
given_passwd = ask_passwd();
}
return true; }
Now if strcmp returns anything but 0, the code inevitably runs into undefined behaviour, therefore the compiler is allowed to assume that never happens, and therefore is allowed to optimize the code to simply
I did not claim that I'd be allowed to distribute the binary without source. Rather I claimed that if I distribute the binary, then I distribute code, and therefore I'm then bound to the GPL which then requires me to give also the source.
Of course we can get some angular resolution. However consider that for a shadow, the signal strength is roughly the shadowed area over the total area of your pixel. For 0,05 arcsec (according to Wikipedia, the best resulution VLA can reach, although probably not at the wavelength of the CMB) and a distance of 4 light years (about 4*10^16 meters; the distance to Alpha Centauri) this covers an era of about 9*10^19 m^2. On the other hand, a black hole of 1000 solar masses would have a radius of about 1500 km, that is, 1.5e6 m, which gives an area of about 2*10^12 m^2. Which would give a relative signal drop of about 2*10^-8. Note that this number goes down with the square of the distance, so at a more realistic distance of 400 light years, the signal drop for a black hole of the same size would be 2*10^-12. I strongly doubt that this would be above noise level.
The binary is definitely code (indeed, it's the actual code). Therefore if I distribute a modified binary, I distribute modified code. Therefore that case is included in what I wrote.
If it's enabled by a speciality flag which documents the violation of the standard, then it's not broken. But if it's enabled by a generic -On option, I consider the compiler broken. And if the compiler doesn't explicitly document that the flag makes it non-conforming (yes, the documentation is part of the compiler, although it is not part of the executable), then the compiler is broken as well.
Of course space isn't really black; rather it is completely transparent. It's the cosmic horizon behind it which is black. Actually at the horizon there's the glow of the big bang, but it is so heavily red-shifted that we only see it in the microwave range (the cosmic microwave background). Now in principle, when looking in the microwave range, black holes should be detectable as "microwave shadows". However I don't think we can measure microwaves in sufficient angular resolution for that.
and getting mass to 1/3 the speed of light is absolutely impossible
FTFY: and getting mass to 1/3 the speed of light is currently impossible
Actually, it's very possible; about every accelerator in the world does it regularly.
Having said that, getting a macroscopic mass to 1/3 the speed of light is currently impossible. Well, at least when considered from the frame of reference in which it originally was at rest.
Slashdot Mirror
Yeah, those flat panels are so much worse than the old energy-sucking CRTs. And those better isolated houses are so uncomfortable ... </sarcasm>
Your mistake is that you assume saving energy necessarily means using less energy. It can just mean letting less energy escape unused.
Really? Say there is some poisoned food, but you don't know that it is poisoned, and you are hungry. But someone else does.
According to your claim, that other person should not stop you from eating that stuff, because after all, you know best what is good for you.
OK, now you will say "ah, but that's just a lack of knowledge, if I knew what is in that food, I'd certainly decide not to eat it." So let's slightly modify the situation:
You know quite well that there's cyanide in the food, but you believe cyanide would be harmless. The other person knows quite well that cyanide will kill you. So should that other person still stop you?
OK, let's modify again: The person doesn't know that there's cyanide in the food, but only firmly believes it. Should she still prevent your from eating it?
OK, make another slight change: She doesn't believe that there's cyanide in the food, but she believes that God will throw you in hell if you eat that food. Should she still prevent you from eating it?
Now I'm pretty sure that in the first scenario you'd say "prevent" (thus violating your own rule), and in the last scenario you would say "not prevent". But where would you make the switch, and why?
Things are simply not as simple as you want them to make.
I'm pretty sure he meant the Royal Air Force, not the Rote Armee Fraktion.
That's a very strange definition of great. Virtually everyone relates that word to features, intuitiveness, absence of annoying bugs, etc. That is, to properties of the IDE.
And no, that's not a question of mileage, that's a question of proper use of the language.
But how can you define defmacro using defmacro before you have defined defmacro? (And afterwards, it wouldn't make sense because it already is defined).
Can you think of something that is more scary? ;-)
If your speedometer shows a higher speed than your real one, then whenever you are too fast, your speedometer will be showing a too high speed, and therefore you cannot claim not to have known that you have been too fast. However I'm not so sure what the ruling would be if the speedometer shows a too low speed (and it's not your fault for either negligence in getting the car serviced or proven active manipulation, and you weren't so much over speed limit that you should have noticed it even without reading the speedometer).
Actually, it's not completely platform independent. For example, does the following code produce undefined behaviour?
On a 16 bit platform, it does. Of course, 16 bit platforms are basically obsolete (at least for desktop/server software; I'm not sure if there are embedded systems still using 16 bit architectures), and on 32 bit or 64 bit platforms, it will work fine.
To be honest, in this situation I would like the compiler to inform me that it had eliminated some code as it is probably not what I meant. Why not write it like this instead?
int foo(int a, unsigned int b)
{
a+=b;
return a;
}
Then in the calling code:
int *a;
unsigned int *b;
*b=10;
*a = foo(1,*b);
I understand that this is a simple example, but I prefer to write my code like this as it ensures that the pointers are only dereferenced within the scope in which they are declared.
I can tell you at least one reason why you wouldn't want to write the code you did: Your assignment to *b is undefined behaviour because you never initialized b.
I like even more the fact that, given that a diagnostic is sometimes required, but never disallowed, and the text of a diagnostic is not regulated, a conforming compiler may just output on every compilation:
warning: This program might contain errors.
Useless, but completely conforming.
Isn't right shift for negative values implementation defined? So your code may work on some platforms, but not on others.
While what you say is true, I think it's not what they mean. Instead what they mean is compilers taking advantage of undefined behaviour you didn't notice. The compiler is allowed to assume that undefined behaviour never happens, and optimize accordingly. The important point is that this can even affect code before the undefined behaviour would occur. For example, consider the following code, where undefined() is some code that causes undefined behaviour:
Now if a>4, the code inevitably runs into undefined behaviour, and therefore it may assume that a is not larger than 4 right from the start. Therefore it is allowed to compile the complete block to simply
Note that even the assert doesn't help because the compiler "knows" it cannot trigger anyway, and therefore optimizes it out.
I think it is not hard to imagine how this can lead to security problems.
Another nice example (which I read on the gcc mailing list quite some time ago; not an exact quote though):
Now if strcmp returns anything but 0, the code inevitably runs into undefined behaviour, therefore the compiler is allowed to assume that never happens, and therefore is allowed to optimize the code to simply
So there goes your password security.
I did not claim that I'd be allowed to distribute the binary without source. Rather I claimed that if I distribute the binary, then I distribute code, and therefore I'm then bound to the GPL which then requires me to give also the source.
Please read more carefully.
What part of "rural village" did you not understand? Not everyone lives in a town.
If it is that critical, maybe the way to go is to host it at two different hosting providers.
Of course we can get some angular resolution. However consider that for a shadow, the signal strength is roughly the shadowed area over the total area of your pixel. For 0,05 arcsec (according to Wikipedia, the best resulution VLA can reach, although probably not at the wavelength of the CMB) and a distance of 4 light years (about 4*10^16 meters; the distance to Alpha Centauri) this covers an era of about 9*10^19 m^2. On the other hand, a black hole of 1000 solar masses would have a radius of about 1500 km, that is, 1.5e6 m, which gives an area of about 2*10^12 m^2. Which would give a relative signal drop of about 2*10^-8. Note that this number goes down with the square of the distance, so at a more realistic distance of 400 light years, the signal drop for a black hole of the same size would be 2*10^-12. I strongly doubt that this would be above noise level.
The binary is definitely code (indeed, it's the actual code). Therefore if I distribute a modified binary, I distribute modified code. Therefore that case is included in what I wrote.
If it's enabled by a speciality flag which documents the violation of the standard, then it's not broken. But if it's enabled by a generic -On option, I consider the compiler broken. And if the compiler doesn't explicitly document that the flag makes it non-conforming (yes, the documentation is part of the compiler, although it is not part of the executable), then the compiler is broken as well.
I wasn't aware that it was posted on Facebook. Or did you mean Twitter?
Chuck would chuck wood. And he would use that wood for making a ladder, which he then would use to climb out of the black hole.
Which Chuck? Well, Chuck Norris, of course.
Of course space isn't really black; rather it is completely transparent. It's the cosmic horizon behind it which is black. Actually at the horizon there's the glow of the big bang, but it is so heavily red-shifted that we only see it in the microwave range (the cosmic microwave background). Now in principle, when looking in the microwave range, black holes should be detectable as "microwave shadows". However I don't think we can measure microwaves in sufficient angular resolution for that.
That depends on the mass of the black hole. A sufficiently large black hole will not spaghettify you outside the horizon.
Well, the firewall rules for a black hole are easy: You let every packet in, but none out.
FTFY: and getting mass to 1/3 the speed of light is currently impossible
Actually, it's very possible; about every accelerator in the world does it regularly.
Having said that, getting a macroscopic mass to 1/3 the speed of light is currently impossible. Well, at least when considered from the frame of reference in which it originally was at rest.