tell me one thing..

that can c++ bether then c# or c/CLI

Suck. Wait, no, they are equivalent.

they are obv not equivalent since c++ is not net

Avoid lawsuits.

>>4
Lawsuits make crushing loneliness less terrible.

>>5
This is a common misconception. Most people who have gone through a lawsuit are reportedly under a great deal of stress as a result, especially middle-class individuals with a lot to lose. Concordly, Miguel de Icaza has no friends.

>>6
But if you are terribly lonely already, wouldn't a couple of lawsuits from Micro$oft entertain you at least a little bit?

In fact it doesn't seem too far fetched to suggest that you would be able to have sexual relations with, or at least befriend a moderately attractive female lawyer from FSF during the ordeal.

C# is slow as hell. C++ is better, because I hate .NET-environment

lol i made a trade too learn something and forgot that im in /prog/

>>3

C++ can use .NET, but it is not required.

>>9
u say prog is no good for progaming u so kewl xD
Fuck off.

i like c#, but c++ is better.

>>11 when was /prog/ good for anything?

>>13
We are not /b/, we don't play the ``kewl guise'' by saying ``we were never good, deal w/it epic lulz op''.
Go here: http://boards.4chan.org/b/

i dont say prog was never good i say prog was allways a puberal kidy how want 2 be a 1337 haxxer but has not enough knowledge too write something of value so it writes some shit about nigger and autism and that evry one can go back to /b/ and as a result of that obv the less guys with skill louse they intrest on /prog/

You're the same guy that got his thread spammed into oblivion. I'd recognize that poor spelling anywhere.

so what?

This thread is now about .NET. What do you think of .NET? Is it better than the JVM? At least it has tailcalls. It still sucks.

>>18

I believe it's been criticized for being a cut-and-paste job—that is, the language specification was Ctrl-X/Ctrl-V'd out of the Java spec.

Honestly, there probably isn't anyone here sufficiently qualified to talk about both except in the most general terms. I've got some Java experience but no .NET, and I bet the other 80% of the people here (there are probably only like 10 people total—you, me, two Haskell trolls, three lisp trolls, and three spammers) just wouldn't dare dignify Microsoft with their heavenly presence.

Installing .NET(or Mono) or JVM or some runtime which consumes resources is out of the question for me. I don't need inefficient abstraction layers which pretend to separate the "evil native code" from their cozy little toy sandbox.

>>20
FWIW, there have been a couple of attempts to make CPUs do the JVM in microcode. One or two may have even been sold at a profit!

>>19
C# indeed was Java with some syntax changed, but now it clearly is a new language. (and probably will end like C++, a Frankenstein language) I'd take C# over Java any day.
However, I was mostly talking of the VM. I haven't seen/read anything of the JVM, other than all the hacks J*, Kawa, Clojure, ..., have to do to properly function (e.g. Kawa and tailcalls, Clojure and its fabulous stack traces). The CIL and the CLI, OTOH, seem to be a nice iset and VM. If it wasn't for the overly engineered standard libraries (System.Console.HaxMyAnus, etc), it would even be reasonable to write CIL code by hand.

>>22
(System.Console.HaxMyAnus, etc)

This is something that pisses me off about nearly every modern language: the absolutely huge complexity involved in making use of their libraries. Combine that with case-sensitivity (fixable in the IDE), and you've got a lot of RSI from hittingThatFuckingShiftKeySoGoddamnMuch. I think the point at which you start seeing people typing ridiculously long keywords every five seconds (I've seen a lot of programs that are covered with System.out.println and never import System.out, because for some reason example code never bothers!) is when the language designers have descended into a deranged world of fetishizing the great and glorious hierarchy as a method of paying tribute to their OOP God, and have left the real world behind.

I mean, think of how many times people have tried to reform Java syntax in the name of terseness—it's just staggering. But it's the wrong solution; it's the hierarchy and function library that really needs fixing.

To be honest, I actually like function overloading, despite the bad habits it can breed, because it can make it so easy to extend operators. I'd prefer a language that permits both overloading and optional parameters, if we're talking purely about classical imperative tongues.

>>23
The impossible namespacing and the forced classes are there to make it look ``robust'' and ``mature'', and mostly because C#, Java, .NET and the JVM were born when OOP was all the rage.
Java and C#, besides the namespace hell and the long identifiers everywhere, are not the only who suffer from shitCase and theForcedShiftingOfCharacters: Ruby, Python (?), Haskell and C++ (mostly) follow this convention too, C uses lowercase_with_underscores that looks just as bad, it's longer, and still requires shifts.

Also, any reason to prefix everything with (com|org|net|*).mysite.[...]?

To be honest, I actually like function overloading, despite the bad habits it can breed, because it can make it so easy to extend operators. I'd prefer a language that permits both overloading and optional parameters, if we're talking purely about classical imperative tongues.
Haskell, IMO, does the right thing here, with type classes. They really help to not get into full retardation and overload add(int,string) and to organize polymorphic procedures better.

>>7
attractive female lawyer from FSF
ihbt

>>14
fuck off and die, faggot

>>25
Moderately attractive. That means after a nuclear war you might find it attractive.

>>24
The underscore practice is actually more of a venerable thing: it dates back to Multics, which was the first filesystem that supported names longer than 8 characters. When you stare into the C and Unix long enough, you start realising that there are a lot of very fundamental design choices that weren't deliberate at all; they were just familiar and consistent with Multics at the time—and those decisions were mostly hacked out by committee in the mid-sixties.

I was definitely happy with how Haskell handled its type classing structure, although at the time I was taught about them, the professor stumbled through it and we all did very horribly on applying Num, Ord, and Eq consistently on our tests. But, like with anything that doesn't conform to 'worse is better', there will always be limits on how much effort it will save you overall.

>>23
>>24

using c = System.Console; //.com.Mysite.StupidClassName.Stupid etc.
namespace prog
{
    class main
    {
        public static void Main (string[] args)
        {
            c.WriteLine ("wanh wanh namespaces are too long");
        }
    }
}

>>29
I mentioned that already. Java's import System.out would allow you to just use println directly.

Now explain why no example code ever does that basic and obvious task—it's a cult of stupid long names.

also forgot to mention that you cannot do this in Java
http://www.javacamp.org/javavscsharp/namespace.html

>>30
it's a cult of stupid long names
I thought it was a programming language. I'm not going to explain why code that you've read and not even referenced here "ever does" namespace aliasing. I would imagine that "example code" is meant for teaching beginners, perhaps the authors thought that using this feature of C# would be confusing to those reading the code.

I'm pretty sure at this point u are just mad over semantics bro.

>>28
Well, Unix not being consciously designed is not something new.
``Worse is better'' is absolute bullshit, worse is enemy of better, which is enemy of perfect. If you really have to follow some principle/philosophy, you should just do The Right Thing.

>>33
I agree with you completely; I'm just saying that perfect is hard.

>>32
I thought it was a programming language.
In this case, "it" is the people responsible for the language, not the language itself. A programming language cannot be a cult, but a community can.

And no, I can't provide a bundle of source code to back up this (mildly paranoid) feeling, but it was an impression I got in both my informal and formal introductions to Java. I didn't even know about import until we started working with Swing (shudder), to be honest. It's unfortunate that they believe this will make life simpler (consider that every example C program ever seems to start with #include <stdio.h>, or some variant!) because my experience with Java was very much negatively tainted as a result; it makes the language feel a lot more bureaucratic than it needs to. That, and naming classes shit like SQLException.

>semantics
Nope. We're not arguing about semantics at all. Go get a dictionary. You mean 'trivial differences of representation' and semantics is about making distinctions between the concepts being represented. Time to hit up Gottlob Frege.

>>33
As awesome as it is to do the right thing, I've been in the computer business long enough to know that to know that the right thing may take too long to accomplish within a given time period. Worse is better is a matter of expedience and practicality in many cases that I've experienced.

>>34-35
Of course doing The Right Thing is harder and takes more time than doing something ``Good Enough'' that ``Just Works'', but it also is source of possible subtle bug because it encourages the software to be inconsistent and incorrect in the corner case, just to save simplicity (and no, an inconsistent and mostly correct with subtle incorrectnesses is not simple to cope with.)
I do think that we should sacrifice a little more time for correctness.

>>36

Clearly it's a trade off. If you take your argument to it's logical extreme we have to do formal proofs of correctness. There's a lot to be said for being first to market, or even just fucking building something, anything and doing incremental development. Of course writing a load of crap and leaving in bugs is a clearly a bad idea too.

That said, worse is better is not about cutting corners, it's about simplicity or crudeness of design based on the idea that you don't fully understand the correct design until you've got a first version. A simpler or more crude design is also more flexible, and you haven't spent as much time on it, so moving to a correct design takes less time in total.

C# is certainly much better than Java, IMO.

Although I prefer how close traditional C brings you to the machine. Fuck abstraction that's already done for you.

deppricated

>>38
close [...] C [...] to the machine.
Wrong. It just lacks abstraction power, which makes it appear ``lol low-level so power so control over machine xD''.
Try Assembly.

>>40
Because Java and C# are just as close/closer?

In addition, pointers and structures make it pretty simple to abstract. Dunno what sort of C programming you're doing.

>>41
There exist only C, C++, Java and C#?

Please, write a simple kernel that enters in protected mode in pure C.
Let's make this simpler, write a bignum library that takes advantage of x86's carry flag, adc and sbb.
Ok, all that is heavily architecture dependent, let's make it even simpler: Jump to a procedure. No? Manipulate the return stack? Neither? What kind of low-level programming are you doing if you haven't even control over the return stack?

Do you think low-level programming is all about accessing the OS API? What about OSes written in high-level language? Don't confound system programming with low-level programming, any language out there can act as a system programming language as much as C. Bit-twiddling? It's not like other languages don't provide bytevectors and bitwise operations. Short, int, long, unsigned and shit? My architecture has support for arbitrary-precision arithmetic were there's no distinction between them, what about now? (That falls under the bit-twiddling umbrella) Even Python has struct unpacking, again just it's playing with bit and bytes.

And don't even try to say it is a portable assembler, which is complete bullshit and you know it. There's no such thing as a portable assembler, especially because some architectures may be particularly hostile to C.

>>41
pointers and structures make it pretty simple to abstract.
Nope. Even a macro assembler has more abstraction power than C.

>>42
It is a portable assembler, and you are a fucking faggot.

>>44
Says who?

>>45 Mr.T

>>46
U so random xD
Get out.

>>47
CHILL OUT.

(-︢  ̱-︡   )

(lambda (x) x)

>>29
Please optimize your quotes.

Being non-proprietary.

>>51
Did you create a progscraper simply so you could reply to every post with unoptimised quotes?