How C# Was Made 391
prostoalex writes "Bruce Eckel (from the Thinking in C++/Java/Patterns/Enterprise Java fame) and Bill Venners have interviewed programming legend Anders Hejlsberg. After 13 years in Borland and joining Microsoft in 1996, Hejlsberg now leads the development of C# language and talks about the development process, reasons some things exist in C# and some not, as well as future directions."
"Co-opt Java" (Score:2, Informative)
Interesting Hejlsberg article (Score:5, Informative)
Interview on the .NET Show (Score:5, Informative)
More about Anders Hejlsburg (Score:5, Informative)
Here's a direct link to the Artima articles... (Score:5, Informative)
Re:More about Anders Hejlsburg (Score:5, Informative)
No, it most certainly is not!
First its Hejlsberg, not Hejlsburg. "Hejl" is pronounced just like "Heil", as a german would in a WW2 movie
So its "Heils-bear"
It was a piano joke. (Score:1, Informative)
Re:"Co-opt Java" (Score:2, Informative)
Checked Exceptions (Score:5, Informative)
Actually, Java supports both checked and unchecked throwables: the latter with the class Error. My programming style is to make throws that I don't expect to be "routinely" caught throw Errors rather than Exceptions. An Error can still be caught, but since you don't expect it, you needn't declare it.
The checked exceptions are still useful for the case where it would probably be a bug not to handle the exception, e.g. "search found no element" or "file not found". The reason for the two kinds of throwables is exactly this: you don't want to declare that every method doing division throws DivideByZero. Unfortunately, the Java library designers don't seem to have gotten it, and so there's a bunch of things like IOException that IMHO should have been Errors.
Re:Sun Should Embrace and Extend (Score:4, Informative)
Go here [sun.com] and when you done, go here [sun.com] and get it.
When you are done playing, come back and see if your post makes sense.
Re:Because pseudo-compiled languages are better.. (Score:3, Informative)
You can get garbage collection and array bounds checking in fully compiled languages (such as D [digitalmars.com]), too.
And you'd better still worry about such things to a certain extent, or else you'll be throwing exceptions on legitimate usage cases when your fixed-size buffer turned out to be too small, running out of memory because you didn't bother nuking references to old objects, etc.
Re:Checked Exceptions (Score:5, Informative)
Unchecked exceptions should be derived from the RuntimeException class. Generally subclasses of Error are not meant to be caught ("An Error is a subclass of Throwable that indicates serious problems that a reasonable application should not try to catch" - from the Javadoc for Error).
you don't want to declare that every method doing division throws DivideByZero
That doesn't throw an exception/error at all, it returns NaN [sun.com].
there's a bunch of things like IOException that IMHO should have been Errors
IOException is something that needs to be checked. It can occur because of low disk space, broken network connections (including NFS mounts), bad character coding, etc. Even FileNotFoundException is a subclass of it.
missing the point, but it doesn't matter (Score:5, Informative)
But it really doesn't matter. The changes that C# made relative to Java are obvious and proven (e.g., value classes, removal of statically checked exception declarations, declared unsafe code sections). Many of them had made Sun's bug parade. All of them had been in other languages before either Java or C#. In fact, C# is, in many ways, close to Modula-3.
There seems to be another reason for some of the design decisions: patents. Sun has patents on several aspects of the JVM and Java, and if Microsoft wanted to be free of potential future claims by Sun, they had to avoid those in their own competing virtual machine.
Keep in mind that Hejlsberg is also a salesperson for the language anyway. That means that he may not be telling you the real reasons behind design decisions, but the reasons that sell the language well.
In any case, however it came into existence, C# is a somewhat better language than Java, and we should be happy about that: whether you are planning on using C# or not, it raises the bar for what is considered standard in industry. Without C#, Sun probably wouldn't even have made the largely cosmetic changes they made to Java in 1.5, and maybe the continued existence of C# will force them to fix other misfeatures of Java and the JVM in future versions. And C# (but not
Re:More about Anders Hejlsburg (Score:4, Informative)
I should know, as we come from the same country.
Re:oh, and what's the next release of Java have? (Score:3, Informative)
The Microsoft CLR has support for many of these features (and others) built into the underlying framework. As a result, things like Generics in C# are about a hundred times as functional and advantageous than they are in Java. Read the article that was linked to in this story, and it will readily become clear that Java is playing catch up at this point. The C# creators really thought of these things *up front* and designed the framework for them, and it really shows.
One of the best examples of this in the interview is that of generics. In C#, if you declare a List of Customers (List), you can see that all the way down to the Reflection/introspection level. It really, genuinely is a List of Customers. However, in Java, because they have to live with their inferior framework, a List of Customers at the Reflection level is a List of Objects... hence, its just an illusion. You get the type checking at compile time, but lose performance advantage and true Generics support.
Thank God for the folks at Ximian though! I really like much of the
Templates are strong typed in C++ (Score:5, Informative)
I disagree with that assessment. Both C# and C++ generics/templates are strongly typed. It's just that the enforcement happens in different places.
In C++, if you try to stick a class into a templated class when that class doesn't have a particular member function defined, the compiler will yell at you, just like Hejlsberg said. But for some reason, this doesn't count as type checking? Yes, template error messages can be strange (and very long) if you're not familiar with them. But that's just a lesson in "know your tools."
To me, "strongly typed" is strict type enforcement at compile time. C++ templates certainly do this.
Constraints, however, are something that I think are a generally good idea. Stroustrup's reasoning for not including them in C++ was that "Requiring the user to provide such information decreases the flexibility of the parameterization facility without easing the implementation or increasing the safety of the facility." (The Design and Evolution of C++, Stroustrup, 343).
He does, however, show an interesting way to get around this using inheritance:
template <class T>
class Comparable {
T& operator=(const T&);
int operator==(const T&, const T&);
int operator<=(const T&, constT&);
int operator<(const T&, const T&);
};
template <class T : Comparable>
class vector {
};
(The D&E of C++, Stroustrup, 344)
This technique is similar to how C# does constraints, class List where T: IComparable. One is supported and enforced by the language, the other is a natural consequence of the languages facilities. In general, I think that constraints are probably a good thing. Having an error message like "Can not instantiate class Y<T> because T does not implement z()" is probably best, and when looking at a class' declaration, it would be nice to see up front what assumptions the templated class makes.
Re:Its not redundant (Score:4, Informative)
In your example, I know with complete certainty that I am creating a new "Type" and assigning it to the variable "varName". This is not the case if it used the syntax of Python. How do you know I am not calling a method called "Type"?
You don't know, and you shouldn't.
Suppose at first you do, in fact, instantiate a new object via the 'Type()' call. Later, during the optimization phase, you discover that in most cases you can return a reference to a pre-existing, pooled object. In Python, you can make that change without breaking client code; not so when object creation is explicitly annotated.
As to whether Type is a method, function, or class constructor, it doesn't matter as long as the returned objects implement the required interface.
Re:worst C# drawback (Score:4, Informative)
There are plenty of people working on tons of free libraries out there. The gotdotnet workspaces are pretty good place to search for things, but your best best is to follow the weblogs on asp.net.
Re:worst C# drawback (Score:4, Informative)
How about you write your own getter/setter macro and publish it there ? That is how a community is built, slowly but surely.
Re:Language/tools are secondary (Score:3, Informative)
Completely true.
In a time when tools are myriad, code can be found for free, and the Internet archives and Google searches lessons and tutorials for us, software developement is crazy. And its funny and ironic that the most essential part to software developement, the developement (it's process: the drafting, coherent, problem-solving design, habitual testing and review, documentation, etc.) is seen as expendable!
Someone somewhere once had the great idea to cut back in software developement - make an unrealistic timeline, change the project's goals and pretend the code will reflect those changes, switch people in and out during developement like nodes in cluster, outsource, skip some testing or only test what you know works, etc.
You are right. Programmers, engineers, etc. can make wonders with far fewer resources, capable tools, and little financial incentive. But without some sense in the process, without a plan to succeed and solve problem(s) with this software (especially adherence to the plan), whatever wonders may have been created are lost in bad habit. So what happens in a lot projects (probably the majority)? Let's buy more resources, more capable tools, and dump other things into the developement.
Fifth grade, I had a teacher who made us repeat a short sentence to her everytime we "forgot" to do our homework:
"Mrs. H, I failed to plan to succeed."
And everytime we said it, it was true.
Re:worst C# drawback (Score:2, Informative)
no source code included, but if you need it, I can email that to you.
Re:Why does C# have redundant syntax? (Score:3, Informative)
int i = new int(1);
No heap allocation has occurred, we've just allocated an int32 on the stack and dumped the output of the int32 constructor into it. That new keyword is really just an indicator that tells us we're calling a constructor.
And how about this:
int[] ints = {1, 2, 3, 4, 5};
That just allocated a new heap object, and there's no new keyword in sight...
(Before anyone argues that that's just like string s = "hello", it isn't... string literals are constants, they're pulled out of the interned string pool when they're referenced. Array literals like the one above are created in bytecode on the fly.)
Brief Historic Note (Score:2, Informative)
If you remember what happened a while ago, the story goes: Microsoft was facing competition from Borland, so they hired away all their lead developers to break the company's neck.
It almost worked.
PS: Don't use anything that has a '#' in it and isn't music!
Re:"Co-opt Java" (Score:2, Informative)