This is exactly what I was thinking, but unable to verbalize it so well.
171 karma · joined January 12, 2012
This is exactly what I was thinking, but unable to verbalize it so well.
OR, she can be a normal, non-litigious person and reject you. She can say "no", turn her head, take a step back, etc. and you know what, she won't be worse for the wear, mentally or physically. I promise!
I mean, at that rate, a girl could indicate that she wants you to rub her off, but charge you for sexual assault because Simon Didn't Say Touch My Breasts. Good god, please let this never happen to anyone.
Please, stop spreading advice that any and all action must be done with full and explicit consent. American society doesn't value that. Watch romance movies sometime. This is what girls grow up with. This is how many girls wish to be treated. They know how to operate in those scenarios. They understand the roles of each and have predefined expectations long before you meet them. They want their lives to play out like the most romantic scenes from their favorite movies. They want spontaneous adventure. They want unexpected trips and kisses in the rain. They want to stare in your eyes and for you to lean in. Defy these norms at your own risk.
I mean, fundamentally, what you are saying is just that: go against cultural norms because it's better for the girl that way. Says who? You? Her? "Society"? Feminists? Movies? I, for one, do not buy this line of thinking.
In the beginning, I expect relationships with people who aren't too sure about each other might well be represented by a series of try { } catch { } and throw CourtshipAdvanceNotAcceptedExceptions. Fine, this is par for the course. This is quite a bit different from throwing a lawsuit.
The people you should worry about are the ones who after rejection occurs, grab their victim and proceed to force their actions anyways.
This check is obviously erroneous, and found via SCA. I was saying "if I had a dollar for every time I found this [via SCA] I'd have a lot of money."
if(obj == null && obj.isValid())
I'd have approximately 960 dollars per project.
Compiler writers can do whatever the heck they want, and if dumping ALL THE WARNINGS was the priority, you'd need three lines of command line switches to turn off the "noise" warnings. Clearly, the a bunch of people see it as "noise" or don't care about writing clean code. That's more systemic of programmers.
If you told C "make me a sandwich", it'd give a warning about not having enough mustard to cover your entire body and an error about not have a large enough bun type to fit you in.
C isn't broken. Gah. Why does everyone have such a hard time understanding that? The language does //exactly what you tell it to do//. If that's overrun a buffer, then that's what you get. If it is fallthrough a switch statement, that's what you get. If it is typecast a block of memory that is too small to hold the structure, then that's what you get. In short, for many programs, that means doing stupid things at some time. For many programs, edge cases aren't considered at all. Blame C? It let me?
For every single one of the "warts" of C, there is also a usecase. This is why it will not be "fixed" and why it isn't "flawed". To remove them is to remove a useful function that could otherwise cause more machine code to be needed. THIS IS THE KEY. Minimizing machine code (overhead).
If you aren't good at managing these edge cases, don't need native code, don't need interop with other code, can take a performance hit, or don't want to use automated tools to help you, then don't use C for large programs.
Take it for what it is: a low level, mostly portable, mask over assembly. Stop complaining about C, start complaining about programmers.
The question (which is unethical to research) is "does voluntary pedophilia harm children?"
In all honestly, the answer is "probably most of the time". Right now, we can't say with absolute certainty that the answer is "probably most of the time". However, the cost of finding out the answer is via a controlled experiment too great, and given the ethics of science today, it definitely shouldn't be researched. We have a lot of reason to believe that children aren't mature enough to handle the consequences, and there are very common negative consequences associated with pedophilia that have been noted for decades. This evidence strongly points to the idea that it is bad, but it isn't proof any more than an apple falling is proof of gravity (it's a case for, but not a proof of). Our society saying "it's bad" isn't proof either.
What Stallman is writing is that he is skeptical of the claim that it is bad. That is a belief, and as already mentioned, testing it would be incredibly unethical. That doesn't make you a bad person for saying that without proof, you refuse to accept a claim.
While what he says may seem heretical, to burn him as a heretic is wrong. Until he says "we should test this" or "I support this group and/or changes of current laws", he hasn't suggested anything that would endanger/harm anyone. The proper response isn't "HERETIC", it is facts that we do know that suggest that this belief is likely (even if not proven in a formal study to be) wrong. For example, bed wetting, PTSD, sexual repression, hypersexualized behavior, extreme depression are symptoms experienced later in life. I don't know what the voluntary/involuntary ratio is, but this suggests that there are serious psychological consequences. Experts in the field would know more. The point being that in an open society, we discuss and counter, not silence and shut down.
Many people believe P = NP despite the years of no solution and a general consensus that researching a polynomial time algorithm is a waste of time. We don't have a proof that P =/= NP, so we can't counter, so we can't counter those who believe it, even if we regard their beliefs to be misinformed or likely to be wrong.
Ah, Java code at my workplace.
catch(Exception e) {}Memory corruption? Appropriate response: fail. Logic error? Appropriate response: fail. Exception? Appropriate response? Decide if program can continue, respond.
I'd say the bigger issue is less of "exceptions" so much as "states". Adding any kind of error handling increases the number of state conditions that your program may be in, and that complexity is obscenely hard to manage. I don't think C or C++ or Java or Erlang or any other language will free you from the burden of proper software engineering.
EDIT: It isn't to say there is exists no discrimination, but if you're running an e-business, the question of sexuality or gender identity does not come into play whatsoever, nor should it ever. I'm not sure how someone would be able to find out either of these to even discriminate against you unless you took the time to specifically advertise them. How you choose to invest the money you make as a business person (e.g. help other transfolk) is purely a personal concern.
1) Fast enough? I have tried git. It's pretty cool, but the difference between 5 seconds and 1 second is minimal at best to me. I don't think I've found myself dying for a faster SCM, though I usually make maybe 1 - 5 commits per day. Git on Win32 is meh compared to git on Linux, so that doesn't really convince me any further either. Git is also a PITA to compile on !Linux using !gcc, because heaven forbid we write using ANSI/ISO C.
2) Yes? I can do renames, but strictly speaking it is not an atomic "rename" operation. I don't particularly care about rename history, and I'm not really sure why others do, but I guess if I tried I could make up a use-case for it. Still, it wouldn't be a selling feature for me, that's for sure.
It seems strange to me that you take the time to tell us that "git is better", like we're comparing O(n) to O(log(n)) algorithms. Different workflows, projects, and organization structures have different needs. It seems hopelessly naive to simply assume everyone's needs are best fit by git, and git alone.
How about this: I want to tell, given two revision numbers in the mainline branch, which came first? In SVN, it's pretty simple. In git? Well, first open a terminal...then ...argh. As release manager, it's kind of annoying. Simple use case: is 2aa8aca05357004d4418807c06f53d81517bc629 before or after e8d0555ce401b6acb0f225aa0263e9b72136347d? Did e8d0555ce401b6acb0f225aa0263e9b72136347d make it into the build given that 5b5c73ceaa442bafff08b4470aad3ff276be94e3 was the final commit before the cut-off?
I might waste 5 seconds opening a terminal window or tab, 30 seconds finding, copying, and pasting the revision numbers, then a second or two determining the answer. This, to me, is not a productive use of my time when revision numbers simply tell me what I need to know. All of that magical time git just saved me might have just been absorbed or gone into time debt.
#include <stdint.h>
uint32_t load_uint32_be(uint8_t* p) { return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]; }
uint32_t load_uint32_le(uint8_t* p) { return (p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0]; }
===============
gcc -O3 -fomit-frame-pointer -S bo.c
===============
load_uint32_be: movl 4(%esp), %edx
movzbl (%edx), %eax
movzbl 1(%edx), %ecx
sall $24, %eax
sall $16, %ecx
orl %ecx, %eax
movzbl 3(%edx), %ecx
movzbl 2(%edx), %edx
orl %ecx, %eax
sall $8, %edx
orl %edx, %eax
ret
load_uint32_le:
movl 4(%esp), %edx movzbl 3(%edx), %eax
movzbl 2(%edx), %ecx
sall $24, %eax
sall $16, %ecx
orl %ecx, %eax
movzbl (%edx), %ecx
movzbl 1(%edx), %edx
orl %ecx, %eax
sall $8, %edx
orl %edx, %eax
ret
GCC doesn't merge the 4 byte-level reads into one 32-bit read. Thus, it does cause some performance penalty. The true impact is probably quite low, but it does exist on x86.It is true however, that GCC will take a series of bit ops and produce a 'bswap' instruction on x86, but that requires a full 32-bit word to start with.
I think it is extremely naive to assume that the CPU's underlying architecture and microarchitecture are utterly mundane details abstracted by the C++ compiler, ESPECIALLY in the case of consoles. Consoles are underpowered by today's standards, and making today's game run on them requires a deft maximization of both the GPU and CPU, not a mindset like "well C++ will take care of the CPU stuff". In case you hadn't figured it out, common C/C++ stuff from Havoc Physics to little old memcpy() and strcmp() are all hand-optimized for their platforms -- sometimes multiple implementations that make use of various ISA extensions. Try stepping through them in a debugger sometime.