Slashdot Mirror
Microsoft Releases C# Language Reference
Snoop Baron writes: "Microsoft has released information about C# on their Visual Studio homepage; the article includes an early version of their C# Language Reference. After having browsed the C# Language Reference PDF I believe they have made some mistakes that Java thankfully avoids. What do you think?"
On the whole, Microsoft seems to have taken Java, added many of the things people were asking for, and called it C#. Barring any big blunders, it's not a bad language. It's "give the customer what they want", but whether that is prudent language design is another question.
But, then, Java is evolving. And that's the crucial point: it's fairly easy to write a language description. It's much more difficult to implement it, work out the gotchas and bugs in it over years of practical use, and actually deliver a high performance, robust implementation with as many features as they stuffed into C#. Java may yet end up incorporating many of those features before C# even sees the light of day (if ever).
What should Java take to heart from this list? My favorites are: by-value structures, foreach syntax, automatic boxed/unboxed conversions, true multidimensional arrays, multiple classes per source files, checked/unchecked arithmetic, get/set methods, and conditional compilation. I think Java also ought to get a generic tuple type. All of those could be implemented without any changes to the JVM (by-value structures would require a new class attribute to actually make a difference in terms of performance). In fact, there are a number of extended Java compilers that do just that.
So, C# is a reasonable idea, but when it comes down to it, it's just like many other Microsoft "me too" announcements. Microsoft just can't seem to let anybody else define or lead an effort. But I don't think they'll be able to take over the world with this one. Java is pretty good, it's quite mature, and it's adding new features at a reasonable pace. Java will get most of C#'s features sooner or later, without changes to its VM. And Java has a big edge over C# when it comes to libraries. Even if Microsoft ever figures out technically how to hook up the Win32 API to C# (and doing that well is tricky), I doubt the result will be anywhere near as comfortable, complete, and safe as the Java APIs.
Hello, world
The canonical "Hello, world" program can be written as follows:
using System;
class Hello
{
static void Main() {
Console.WriteLine("Hello, world");
}
}
The source code for a C# program is typically stored in one or more text files with a file extension of .cs, as in hello.cs. Using the command-line compiler provided with Visual Studio, such a program can be compiled with the command line directive
csc hello.cs
which produces an executable program named hello.exe. The output of the program is:
Hello, world
Close examination of this program is illuminating:
o The using System; directive references a namespace called System that is provided by the .NET class library. This namespace contains the Console class referred to in the Main method. Namespaces provide a hierarchical means of organizing the elements of a class library. A "using" directive enables unqualified use of the types that are members of the namespace. The "Hello, world" program uses Console.WriteLine as a shorthand for System.Console.WriteLine.
o The Main method is a member of the class Hello. It has the static modifier, and so it is a method on the class Hello rather than on instances of this class.
o The main entry point for a program - the method that is called to begin execution - is always a static method named Main.
o The "Hello, world" output is produced through the use of a class library. The language does not itself provide a class library. Instead, it uses a common class library that is also used by languages such as Visual Basic and Visual C++.
For C and C++ developers, it is interesting to note a few things that do not appear in the "Hello, world" program.
o The program does not use a global method for Main. Methods and variables are not supported at the global level; such elements are always contained within type declarations (e.g., class and struct declarations).
o The program does not use either "::" or "->" operators. The "::" is not an operator at all, and the "->" operator is used in only a small fraction of programs. The separator "." is used in compound names such as Console.WriteLine.
o The program does not contain forward declarations. Forward declarations are never needed, as declaration order is not significant.
o The program does not use #include to import program text. Dependencies among programs are handled symbolically rather than textually. This system eliminates barriers between programs written in different languages. For example, the Console class could be written in another language.
[---]
Looks like a bastard child of C and Pascal. A Borland influence, maybe?
--
Evan
"$30 for the One True Ring. $10 each additional ring!" -- JRR "Bob" Tolkien
I just read through the language reference, here's my impressions of C#.
Being able to assign the get/set accessors for properties is a real plus. I always liked that about Delphi, and wished Java had a better way of doing that. The indexers are also neat. Nothing really revolutionary, but very useful.
Having primitives "boxed" and "unboxed" in objects as needed is also neat. Save loads and loads of that Hashtable.put("number 1", Integer.parseInt(1)) type code that is just a pain in the ass, without sacrificing the performance of making everything an object all the time. I like that.
I also like the foreach statement, as it does make the language a little more expressive (though nowhere near as expressive as Perl.) I like coding in Java all day, but the code is just so bland.
However, there does seem to be a lot of stuff left over from C/C++ days that is sort of questionable. Like the inclusion of structs and enums. The potential performance benefits of structs are intriguing, but losing much of the OOP nature of your code is not attractive. Enums seem to clutter the language needlessly.
Delegates are interesting, but it seems as if most of the functionality provided by them could also have been accomplished with use of interfaces. Curious however.
I really dislike the whole notion of the unsafe code blocks, and getting around the garbage colelctor when you want to. Why not use hook in a native interface like JNI to allow that sort of code? Even more, since all oject are COM objects, and since you can pull in outside COM objects so easily, that would seem to be a good fit.
The proliferation of modifiers and qualifiers for methos and classes and variables is quite confusing, but then I expected that, since MS has a heritage of that sort of thing in the Win32 API. Particularly odd is the "internal" modifier. I read it is meant to say "used by this project only." Huh? What happened to inheritance and the like?
In the same vein, I don't fully understand the Attribute support, after several readings. It seems as if you could provide your own modifiers and such, sort of a hybrid interface, but they don't seem to document it much either. How odd. Has anyone made sense of this yet?
The preprocessor can be useful sometimes, I agree, but in many cases it just clutters up the code. I'm somewhat disappointed to see this included. I felt Java's lack of preprocessor was a good step forward.
All in all, it's an interesting language that ties together existing principles and cleans up some of the aspects in the process. But as expected, it's nothing new, and since it is trying desperately to hold on to the legions of Win32 C++ programmers, many concessions were made to old-school thinking at the expense of robustness and security.
Anyone else have comments?
Well, at first glance this doesn't look like an internet language. It compiles into .exe files, and not into bytecodes or anything along those lines.
Of course, this should mean that this is not an internet language, and is just another tool for desktop programs or Windows LANs.
However, knowing MS, this is probably intended to compete with Java despite native compilation. I can even see how that might succeed, in the still-Windows-dominated Internet user environment. This, of course, allows all sorts of brutally bad secuirty holes (native code? hello? anyone home?)
Overall, the language seems to be a cheap replica of Java with some of the statements renamed and a different class set.
Your chronology is incorrect. Active X, the successor to OLE (Object Linking and Embedding), was announced several years before Java. The original purpose was to extend VBXs (Visual Basic Extensions) to other tools. OLE 2.0 was later merged with it. Eventually,ActiveX became "just a marketing term for a collection of technologies" according to Microsoft.
Java was designed for embedded systems (I believe). When the internet came along, it was only an internal project at Sun. Quite a few changes later, the Internet language we think of today was developed.
Given that Java was only half implemented, turning it into an 'internet' technology was easy. ActiveX was designed with entirely different assumptions in mind and couldn't make the leap. Don't assume that C# will follow the same path!
Given one hour to live, the student replied: "I'd spend it with professor FP who can make an hour seem like a lifetime."
Basically, C# is an attempt to combine the features of Java and C++. C# is fully object-oriented (there are no function definitions except as methods) language with many features to make complex programming easier and faster (a la Java).
However, unlike Java, C# compiles to machine code, not byte code. Therefore C# programs do not take the performance hit that Java programs do.
Some interesting features:
automatic garbage collection (can be overridden with the "unsafe" keyword)
explicit pass-by-reference
variables must be initialized before use
every object is a COM object
even primitive types (int, etc.) are objects and methods can be applied to them
no forward declarations
So, it actually IS something new, and (IMO), actually pretty interesting. Now what we really need is GC#, and we may get it, since it was submitted to a standards body.
Thank you for all of your great work in selecting those quotes. You've picked just the right ones that by taking the first word of each, I can decipher their true strategy:
"Embraces emerging Web programming standards"
"Extensive interoperability" (Read: "Extends interoperability"
"Eliminates costly programming errors"
Read the first word of every line... Embrace, Extend, Eliminate! Devious, huh?
Friends don't let friends misuse the subjunctive.
"Eliminates costly programming errors"
What's this, has Microsoft legislated good programming? Like the old saying goes, 'When a programming language is created that allows programmers to program in simple english, it will be discovered that programmers can not speak english'.
"Embraces emerging Web programming standards"E mbraces emerging web programming standards'
Originally 'Creates^H^H^H^H^H^H^HInnovates^H^H^H^H^H^H^H^H^H
"Extensive interoperability"
Everything is a COM object, so EVERYTHING can now be used by malicious ActiveX critters to cause new and improved and more effective destruction!
Read it for what it is, a Microsoft.NET vehicle.
You think I mean the Microsoft collective, don't you? No, I mean the Slashdot/Open Source collective. It seems that most of the people on Slashdot act as one combine collective intelligence, with just as much predudice and non-intelligence as a single person.
As one would expect, almost all of the high-scoring posts here are extremely negative, because the collective holds the opinion that Microsoft can not possibly create something good. Though some of these posts are correct, many are completely wrong. One score 5 post said nothing except that C# allowed implicit variable defining, and that this was bad. C# does not allow any such thing.
Anyone who is looking for an honest opinion of C# should not look here.
BTW, I am not a Microsoft supporter. I use Linux. I am not saying that C# is necessarily good, but it is no where near as bad as everyone here seems to think.
Go ahead, mod me down. I have karma to spare.
------
the following is from a reasonably serious Java developer's point of view:
Obviously this is a Java ripoff. That does not make it bad; in fact, if a language copies the good ideas in Java, that makes the new language good. In my *really* quick glance through the white papers, the best thing they've added are the new things that C# interfaces can define, like events and variables. Java interfaces don't have assertions, and sometimes those are really nice to have.
Bad things:
Speaking of Java itself, wanna bet that Microsoft deep-sixes J++ and discontinues its VM now that it has this, "suggesting" that new developers move to C#?
<spit> Lousy bastards. Would love to have those interfaces in Java, though. :)
"Honey, it's not working out; I think we should make our relationship open-source."
Here's an article from the other architect of delphi on the guy.
He was also the guy behind the WFC for java that started the lawsuit rolling between microsoft and sun.
My god! Do they know what the key signature for that looks like?!? No WAY I'm playing in a key with 8 sharps.
----
I can write in a language that doesn't really exist for a platform (.net) we may never see. Fortunately, I can use a vapor-protocol (SOAP) to communicate between these non-existent apps. I hope that MS will come up with some even-more-proprietary extensions so I can hook it all up to my Cairo-based BizTalk server.
Someday a Slashdot ID of 177180 will mean something.
> My god! Do they know what the key signature for
> that looks like?!? No WAY I'm playing in a key
> with 8 sharps.
Relax; it'll never be more than a minor
language, so there'll be only 4 sharps.
Chris Mattern
Innovations aside, here's what scares me the most:
..uh...27"
Variables in C# are automatically initialized by the environment.
Uh...does this mean they have a little paper clip drop down and say "Looks like you forgot to initialize your variable...don't worry..I'll assign it to