Plan 9 Uses are total nutjobs
1
Name:
Anonymous
2011-01-07 4:27
"Why?" you surely wonder. Actually, I didn't want to start
yet another C++ discussion, mostly because alot of links from cat-v.org would fit perfectly in this context.
But there is this particular site of cat-v.org, that literally screams
"HEY! LOOK AT ME! I'M LOUD! I'M ANNOYING! I SAY THINGS! I CRITICIZE EVERY POSSIBLE ASPECT! LOOK AT ME! LOOK AT ME DAMMIT". That particular site is:
http://harmful.cat-v.org/software/c++/
Okay, just a boring link to an interview with Stroustrup (the billionth this time), where stroustrup explains why he 'created' C++ (again, a topic that had been discussed a billion times before).
But it's more about the quotes, not the link. It includes classy ones like this:
"If you think C++ is not overly complicated, just what is a protected abstract virtual base pure virtual private destructor and when was the last time you needed one? " ---
The author could as well have said:
"I don't understand language $XYZ, so it must be a) extremely bad, b) the work of satan himself c) the work of communists", instead of saying
"I don't understand language $XYZ, but maybe it's because.... I never learned it! Or because I never bothered to learn it to begin with" - Not on cat-v.org. No.
Another fairly ``common'' argument against C++ is the lack of a Garbage Collector. My question is, why does a language that never creates garbage, a garbage collector? A GC is used in a language that doesn't run natively (read: compiled to machinecode, and the machine just runs the code literally), since the Virtual Machine has to organize allocated chunks somehow.
But since C++ doesn't run in a Virtual Machine, and therefore doesn't have a layer that is required to keep track of allocated and de-allocated references, the need of a garbage collector is simply void.
Don't get me wrong though, not everything of cat-v.org is bad; My personal favourite is this one:
http://harmful.cat-v.org/software/GNU/ - Because it's simply the truth. Fuck GNU.
Oh dear cat-v.org, please continue to exist for the next thousand years, so that we always have something to point and laugh about (but mostly only the authors of cat-v.org themselves, of course).
2
Name:
Anonymous 2011-01-07 4:29
alot Fagot .
3
Name:
Anonymous
2011-01-07 4:31
>>2
I'm afraid I have to tell you that i'm most certainly not a musical instrument, Mister
[spoiler] ``
SUPER [sub] [i] Faggot
[i] [/sub] ''
[/spoiler]
4
Name:
Anonymous 2011-01-07 4:32
>>1
You don't need a VM to have a GC. A lot of languages compile to native code and still have a GC, even some system languages. I'm not saying that C++ should have had a GC, just that a GC does not mean your implementation must be VM-based.
5
Name:
Anonymous
2011-01-07 4:41
>>4
True, D has a builtin GC. The problem being, that the GC practically eliminates the need for RAII in D almost entirely, as the GC would catch memory chunks anyway... It's still kind of ironic that the GC of D happens to fail that most of the time, which still forces you to manually delete chunks.
6
Name:
Anonymous 2011-01-07 4:57
Yet another C++-defending discussion.
>>1-2
Fuck off and die, you fucking fag.
8
Name:
Anonymous 2011-01-07 5:47
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
●█████▄▄▄▄▄▄▄▄
520
Name:
Anonymous 2011-01-07 7:50
●█████▄▄▄▄▄▄▄▄Sage Tank███████►
521
Name:
Anonymous 2011-01-07 7:51
●█████▄▄▄▄▄▄▄▄Sage Tank███████►
522
Name:
Anonymous 2011-01-07 7:51
●█████▄▄▄▄▄▄▄▄Sage Tank███████►
523
Name:
Anonymous
2011-01-07 7:52
Oh god it's Captain Autism .
524
Name:
Anonymous 2011-01-07 7:52
●█████▄▄▄▄▄▄▄▄Sage Tank███████►
525
Name:
Anonymous 2011-01-07 7:53
●█████▄▄▄▄▄▄▄▄
526
Name:
Anonymous 2011-01-07 7:53
●█████▄▄▄▄▄▄▄▄
527
Name:
Anonymous 2011-01-07 7:53
●█████▄▄▄▄▄▄▄▄
528
Name:
Anonymous 2011-01-07 7:54
●█████▄▄▄▄▄▄▄▄
529
Name:
Anonymous 2011-01-07 7:54
●█████▄▄▄▄▄▄▄▄
530
Name:
Anonymous 2011-01-07 7:55
●█████▄▄▄▄▄▄▄▄
531
Name:
Anonymous 2011-01-07 7:55
●█████▄▄▄▄▄▄▄▄
532
Name:
Anonymous 2011-01-07 7:56
●█████▄▄▄▄▄▄▄▄
533
Name:
Anonymous
2011-01-07 7:57
●█████▄▄▄▄▄▄▄▄
534
Name:
Anonymous 2011-01-07 8:05
>>533
Sagefault (Thread bumped)
535
Name:
Anonymous
2011-01-07 8:11
>>534
536
Name:
Anonymous 2011-01-07 8:33
>>535
#define Sagefault puts>>535 and "
537
Name:
Anonymous
2011-01-07 13:35
I read 4chan because I enjoy watching people who are depressed, suicidal, antisocial and socially abused talk about their life like they are normal and have no problems
538
Name:
Anonymous 2011-01-07 15:05
539
Name:
Anonymous 2011-01-07 16:24
>>538
Too slow Rails as Fuck is
Bad on Ruby
540
Name:
Anonymous 2011-01-07 18:38
>>539
Too fuck Bad on Rails is
SLOW AS RUBY
541
Name:
Anonymous
2011-01-07 19:15
>>6-536
Butthurt LITHP Cocksuckers
542
Name:
Anonymous 2011-01-07 19:18
>>541
Butthurt
"/b/" >>= backTo
543
Name:
Fuck off, !Ep8pui8Vw2
2011-01-07 19:30
>>542
Fuck off,
``faggot'' .
544
Name:
Anonymous
2011-01-07 19:46
>>542
Sorry, I meant to write,
Butthurt HAKSAL/LITHP worshipping Cocksuckers .
Now hush, back to your Xbox, adults are talking.
545
Name:
Anonymous 2011-01-07 20:26
>>544
Back to /v/ please.
546
Name:
Anonymous
2011-01-07 20:35
547
Name:
Anonymous
2011-01-07 21:11
>>546
No, I'm back to /b/ please
548
Name:
Anonymous
2011-01-07 22:46
>>547
fuck off fucking fag, eat shit and die motherfucker
549
Name:
Anonymous
2011-01-07 22:55
>>5
The problem being, that the GC practically eliminates the need for RAII in D almost entirely, as the GC would catch memory chunks anyway
But what about all the other resources? RAII may be a slightly retarded way to manage memory, but leaving a lock (for example) lying around to be collected would be more retarded.
550
Name:
Anonymous
2011-01-07 23:00
RAII may be a slightly retarded
You just disqualified yourself for this discussion, there. Because you think RAII is some magic buzzword, that only applies to C++, Java, or c++-alike languages.
Read
http://www.hackcraft.net/raii/ .
551
Name:
Anonymous
2011-01-08 2:14
>>550
...try reading the rest of that sentence you quoted.
552
Name:
Anonymous
2011-01-08 3:40
>>551
You mean
... way to manage memory
I did read it. Hence why I suggested you to inform yourself what RAII is really about.
553
Name:
Anonymous 2011-01-08 4:59
554
Name:
Anonymous 2011-01-08 14:18
555
Name:
Anonymous
2011-01-08 14:18
Triplez. Check 'em.
556
Name:
Anonymous
2011-01-08 14:32
Dual timer GET
557
Name:
Anonymous 2011-01-08 14:33
>>555
OMGZLOL UR A WIZARD???!???!?!?1'!?!?!?'1?!?'?!?!?!'1'!??!£=)!"=)=!?!?"?!??"?="!=="?
558
Name:
Anonymous 2011-01-08 14:59
>>1
why does a language that never creates garbage
That's why C++ applications don't suffer of memory leaks when C ones do.
Other than that, >>1 never heard of BoehmGC
559
Name:
Anonymous
2011-01-08 15:10
>>558
Bitches don't know about my GC
560
Name:
Anonymous
2011-01-08 15:15
>>558
C has no leaks at all, that is why micorosoft had to introduce a all those _s functions like scanf_s
561
Name:
Anonymous
2011-01-08 16:49
>>560
Windows NT and newer are written almost entirely in C++.
>>558
Other than that, >>1 never heard of BoehmGC
I've heard of BoehmGC. It's a pointless library.
562
Name:
Anonymous 2011-01-08 16:54
>>561
Indeed the WinAPI is written in C++ with C bindings.
Please fuck off.
563
Name:
Darkr
2011-01-09 1:54
C++ has problems but it's not the monster people make it out to be. If it were really that horrible, you wouldn't see so much successful software written in it.
564
Name:
Anonymous 2011-01-09 3:20
>>563
Those are a few of the reasons why we consider C++ to be a monster. How does one reliably use a language that is so hideously complex that it becomes unreasonably difficult to parse? The answer is to not use it, by that I mean that you only use a small subset that is reliable. If you do decide to do that, you may as well move to a different language that isn't so hideous.
565
Name:
Anonymous
2011-01-09 4:08
>>564
you may as well move to a different language that isn't so hideous.
Like...
* VB, which uses XML Literals (ohgod)
* C#, which uses pseudo-SQL syntax (select, dear jesus!)
* Java, which uses 'new' to instantiate a class (my god)
* Haskell, monads (the pain, ohgod the paaaaain)
* Python, which uses forced intendation (why, god, why.)
* Ruby, which is the bastardchild of Python and Perl (Jesus wept.)
* Perl, which uses regular expressions for fucking everything (god has left us)
* Scheme/Lisp, which uses parentheses for fucking everything (hail to our new lord, satan)
* APL, which uses UTF8-encoded syntax elements (please excuse me while i kill some kittens)
I hope you see what I try to say here (
The way you described it makes every goddamn language look bad, not just C++ ); Or you don't, in which case I kindly beg you to go back to
/b/ .
566
Name:
Anonymous 2011-01-09 4:12
>>563
If it were really that horrible, you wouldn't see so much successful software written in it.
That's why java isn't
that horrible, either
!
567
Name:
Anonymous 2011-01-09 4:18
Scheme/Lisp, which uses parentheses for fucking everything
568
Name:
Anonymous 2011-01-09 4:34
>>565
Haskell, monads
Not really. Monads are quite nice once you understand them.
And I hate Haskell.
569
Name:
Anonymous
2011-01-09 4:39
570
Name:
Anonymous 2011-01-09 4:49
>>565
unreasonably difficult to parse
This is referring to lexical analysis, not human readability.
571
Name:
Anonymous
2011-01-09 5:12
>>570
I like how you imply that Monads / XML Literals / Pseudo SQL Statements are easier to parse than Metatemplates in C++. You must be new to this page, yes?
572
Name:
Anonymous
2011-01-09 5:29
>>571
You must be new to not being autistic.
573
Name:
Anonymous 2011-01-09 5:46
>>571
imply
I like how you imply that you aren't new
to this page .
Monads (the do notation) are just ~10 lines of syntax-case.
574
Name:
Anonymous 2011-01-09 7:17
>>571
Yes. I did imply that Monads / XML Literals / Pseudo SQL Statements are easier to parse than Metatemplates in C++.
Monads are trivial. XML is easy. SQL-like statements, I wouldn't know. Metatemplates are just one part of why it is monstrous to parse C++.
575
Name:
Anonymous 2011-01-09 7:26
>>573
I like how you are being a total dick
576
Name:
Anonymous 2011-01-09 7:32
>>574
XML is easy.
XML != XML Literals. Don't make me murder you.
This is what this monstrum looks like:
Even
IF it were just plain XML, parsing it is still not
"easy". But in case of XML Literals, the XML Element is directly translated into an Object.
Metatemplates are just one part of why it is monstrous to parse C++.
Says
OMG PROFESSIONAL HAKSAL/LITHP/RUBEE-KUN (so kawaii ^_^) Programmer.
577
Name:
Anonymous 2011-01-09 15:13
XML Literal(s) is a feature that Visual Basic developers can call their own! The XML Literal syntax facilitates creating XML documents and elements that support the vast majority of the XML 1.0 specification. Complementing the literals are axis properties that aid in navigating and accessing XML elements and attributes.
578
Name:
Anonymous
2011-01-12 16:39
pantsu
579
Name:
Anonymous 2011-01-12 17:44
You guys are going to shit your pants when you hear about "Managed C++."
580
Name:
Anonymous 2011-01-12 18:51
>>579
I heard C++/CLI is the new way to "ALL I WANTED WAS TO MAKE VIDYAGAEMS" nowadays.
581
Name:
Anonymous 2011-01-12 21:29
>>580
No, C++/CLI is "I'm an Indian programmer" these days.
582
Name:
Anonymous
2011-11-17 22:55
neat
583
Name:
Anonymous
2011-11-17 23:00
Please, tell us, what does the following C/C++ code do
584
Name:
Anonymous
2011-11-17 23:34
>>583
The argument you're using to show that C++ is overly complex is a logical fallacy. To prove that point, please tell me what the following Lisp expression does:
585
Name:
Anonymous
2011-11-18 0:19
>>584
>please tell me what the following Lisp expression does:
It's an invalid expression:
1. Lisp cant overload operators
2. #%[divides equal] isnt Lisp.
3. (compM 'ListM) isnt Lisp.
586
Name:
Anonymous
2011-11-18 0:35
>>585
1.
readtable
2.
readtable
3.
readtable
587
Name:
Anonymous
2011-11-18 0:41
588
Name:
Anonymous 2011-11-18 0:51
alot
589
Name:
Anonymous 2011-11-18 1:04
"Why?" you surely wonder. Actually, I didn't want to start yet another C++ discussion, mostly because alot of links from cat-v.org would fit perfectly in this context. Actually, I didn't want to start yet another C++ discussion, yet another C++ discussion, C++ discussion C++
590
Name:
Cudder !MhMRSATORI!FBeUS42x4uM+kgp
2011-11-18 4:18
>>583
Syntax error, unmatched closing bracket.
591
Name:
Anonymous
2011-11-18 8:15
>>587
Lisp is shit.
>>588
fuck off and die you prescriptivist piece of shit
592
Name:
Anonymous
2011-11-18 8:27
>>591
Sorry, but ugly Python is going to die. Stop denying the beauty of Lisp.
593
Name:
Anonymous 2011-11-18 9:08
>>592
Python should die. Lisp is already dead.
594
Name:
Anonymous
2011-11-18 10:54
>>583
I strongly doubt that this is C++
595
Name:
Anonymous
2011-11-18 11:18
Hay guise, whats going on in dis thread?
596
Name:
Anonymous 2011-11-18 11:44
C is shit. C++ is shit. Lisp is shit. Python is shit.
597
Name:
Anonymous 2011-11-18 12:03
C++ is anti-elegance. thread over.
598
Name:
Anonymous 2011-11-18 12:28
599
Name:
Anonymous 2011-11-18 13:27
>>560
Those are not "leaks", those are retarded programmers that can't do addition.
600
Name:
Anonymous
2011-11-18 19:18
>>594
I strongly doubt that this is C++
this
IS C/C++
http://www.cc.gatech.edu/~yannis/fc++/
601
Name:
Anonymous
2011-11-18 19:52
602
Name:
Anonymous
2011-11-18 20:38
>>600
rrrrrrright, because you just HAD TO pick the most obscure way of programming for C++ to prove your point.
jesus, we got it, you don't understand C++, so why don't you just go back to Java already?
603
Name:
Anonymous
2011-11-18 21:00
>>602
Of course I had to, because all other ways sucks even more. FC++ is 100 times better and simpler than BOOST's lambda.
boost::lambda::lambda_functor< boost::lambda::lambda_functor_base< boost::lambda::bitwise_action< boost::lambda::leftshift_action>,boost::tuples::tuple< boost::lambda::lambda_functor< boost::lambda::lambda_functor_base< boost::lambda::bitwise_action< boost::lambda::leftshift_action>,boost::tuples::tuple< std::ostream&,boost::lambda::lambda_functor< boost::lambda::placeholder<1> >,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type> > >,const char,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type,boost::tuples::null_type> > >::operator
604
Name:
Anonymous
2011-11-18 21:05
>>603
please stop trying so hard, you're only embarassing yourself here
seriously, since you love Java so much more, just stick to Java, be happy with Java, and stop acting like you have to justify your habits to anyone.
for the record: boost is known as bloated, pointless, and overly complex by a many C++ programmers, and only masochists use Boost. apart from that, it's sad (very sad) that you pick Boost as the one library to represent C++. Also, FC++ is bullshit, and your "functional programming" ponyfied autism serves absolutely no use whatsoever
605
Name:
Anonymous 2011-11-19 1:10
My question is, why does a language that never creates garbage, a garbage collector?