Slashdot Mirror
C# Under The Microscope
To Begin at the Ending
I'm a big fan of programming languages, possibly more than of actual programming. Every once in a while I hear about this new language that is just "brilliant", that "does things differently" and that "takes a whole different approach to programming". I typically then take the necessary time off my regularly scheduled C++ programming, learn enough about the language to get excited about the new one, but not enough to actually do anything useful with it, rave about it for a couple days, and then quietly and without protest go back to my C++ programming.
And so, when I learned of Microsoft's new up-and-comer, C# (pronunciation: whatever), I became duly excited and went forth to learn as much about it as possible.
Last things first: On paper, C# is very interesting. It does very little that's truly new and innovative, but it does do several things differently, and through this paper I hope to explore and present at least some the more important differences between C# and its obvious influences: C++ and Java. So, skipping the obligatory Slashdot "speaking favorably of Microsoft" apology, let's talk about C#, the language.
How is it like Java/C++?
In the look & feel department, C# feels very much like C++. More so than even Java. While Java syntax borrows much of the C++ syntax, some of the corresponding language constructs have a slightly different form of use. While this is hardly a complaint, it's interesting to note that the designers of C# went a little further in making it look like C++. This is good for the same reason it was good with Java. Being a professional C++ programmer, I use C++ way more than any other language. Eiffel, for instance, has a much cleaner syntax than either C++, C# or Java, and at face value it does seem as though one should bear with new syntax if this is going to lead to cleaner, more easily understandable code, but for an old dog like myself, not having to remember so much new syntax when switching to another language is nothing short of a blessing.
C# borrows much from Java, a debt which Microsoft has not acknowledged, and possibly never will. Just like Java, C# does automatic garbage-collection. This means that, unlike with C and C++, there is no need to track the use of created objects, since the program automatically knows when objects are no longer in use and eventually destroys them. This makes working with large object groups considerably simpler, although, there have been a few instances where I was faced with a programming problem where the solution depended on objects *not* being automatically destroyed, as they were supposed to exist separate from the main object hierarchy and would take care of their own destruction when the time was right. Stroustrup's vision of automatic garbage-collection for C++ sees automatic garbage-collection as an optional feature, which might make the language more complicated to use, but would allow better performance and increased design flexibility.
One interesting way in which C# deals with the performance issues involved with automatic garbage collection is that of allowing you to define classes whose objects always copy by value, instead of the default copy by reference, which means there is no need to garbage- collect such objects. This is done, confusingly enough, by defining classes instead as structs. This is very different from C++ structs, which are defined in exactly the same way; C++ structs are just classes where members are public by default, instead of privately. Another idea that was lifted directly off Java, and one which turned out to be very controversial is that of multiple inheritance. In what seemed like a step backwards, Java did not allow you to define classes that inherit from one than one class. Java did let you define "interfaces", which work like C++ abstract classes, but were semantically clearer: an interface is a functional contract that declares one or more methods. A class can choose to "sign" such a contract by inheriting it, and providing a working implementation for every method that the interface declares. In Java, you can inherit as many interfaces as you want. The rationale to all this being that multiply inheriting more than one class raises too many possible problems, most notably that of clashing implementations and repeated inheritance. On a side note, the cleanest separation between interface and implementation that I know of is that of Sather, where classes can provide either implementation or interface, but not both.
So what else is new?
One new feature that I mentioned already was that of copy-by-value objects. This seemingly small improvement is a potentially huge performance saver! With C++, one is regularly tempted to describe the simplest constructs as classes, and in so doing make it safer and simpler to use them. For example, a phone directory program might define a phone record as a class, and would maintain one PhoneRecord object per actual record. In Java, each and every one of those objects would be garbage collected! Now, Java uses mark-and-sweep in order to garbage collect. The way that this is done is this: the JVM starts with the program's main object, and starts recursively descending through references to other objects. Every object that is traversed is marked as referenced. When this is done, all of the objects that aren't marked are destroyed. In the phone book program, especially if there are thousands and thousands of phone records, this can drastically increase the time that it takes the JVM to go through the marking phase. In C#, you'd be able to avoid all this by defining PhoneRecord as a struct instead of a class.
Another thing that C# does better than Java is the type-unification system. In Java, all classes are implicitly descendents of the Object class, which supplies several extremely useful services. C# classes are also all eventual descendents of the object class, but unlike Java, primitives such as integers, booleans and floating-point types are considered to be regular classes. Java supplies classes that correspond with primitive types, and mapping an object-value to a primitive value and vice versa is very simple, but C# makes it that much simpler by eliminating that duplicity.
Personally, I found C# support of events to be a very exciting new feature! Whereas an object method operates the object in a certain way, object events let the object notify the outside world of particular changes in its state.. A Socket class, for instance, might define a ReadPossible event or a data object might release a DataChanged event. Other objects may then subscribe for such an event so that they'd be able to do some work when the event is released. Events may very well be considered to be "reverse- functions", in the sense that rather than operate the object, they allow the object to operate the outside world, and in my programming experience, events are almost as important as methods themselves.
While you could always implement events in C by taking pointers to functions, or optionally in C++ and Java by taking objects that subclass a corresponding handler type, C# allows you to define class events as regular members. Such event members can be defined to take any delegate type. Delegates are the C# version of function pointers. Whereas a C function pointer consists of nothing but a callable address, a delegate is an object reference as well as a method reference. Delegates are callable, and when called, operate the stored method upon the stored object reference. This design, which may seem less object-oriented than the Java approach of defining a handler interface and having subscribers subclass the interface and instantiate a subscriber, is considerably more straightforward and makes using events nearly as simple as invoking object methods.
Events are one example of how C# takes a popular use of pre-existing object-oriented mechanisms and makes it explicit by giving it a name and logic of its own. Properties are another example, even though they're not as much of a labor-saver as events are. It is very commonplace in C++ to provide "getters" and "setters" for private data members, in order to provide controlled access to them. C# treats such "protected" data members as Properties, and the declaration syntax of properties is such that you have to provide getter and setter functions for each property. In fact, properties do not have to correspond to real data members at all! They may very well be the product of some calculation or other operation.
And then, by far the ugliest, most redundant and hard-to-understand language construct in C# is the Attribute. Attributes are objects of certain types that can be attached to any variable or static language construct. At run-time, practically anything can be queried for the value of attributes attached to it. This sounds like the sort of hack someone would work into a language ten years after it's been in use and there was no other way to do something important without breaking backwards compatibility. Attributes are C#'s version of Java reflection, but with none of the elegance and appropriateness. In general, and especially in light of C#'s overall design, the Attributes feature is out of place, and inexcusable.
What is it missing? Being an unborn language, there is much that C# does not yet promise to deliver, and for which it can't be criticized. First of all, there is no telling just how well it would perform. Java is, in many ways, the better language but one of the prime reasons it's been avoided is its relatively slow performance, especially compared to corresponding C and C++ implementations. It's not yet clear whether C# programs would need the equivalent of a Java Virtual Machine or whether they could be compiled directly into standalone executables, which might positively affect C#'s performance and possibly even set it as a viable successor to C++, at the very least on Windows. While there is much talk of C# being cross-platform, it is unclear just how feasible implementing C# on non- windows platforms is going to be. The required .NET framework consists of much that is, at least at the moment, Windows specific, and C# relies heavily on Microsoft's Component Object Model. All things considered, setting up a proper environment for C# on other platforms should prove to be a massive undertaking, that perhaps none other than Microsoft can afford.
Furthermore, while there is mention of a provided system library, it's not clear what services such a library would provide. C++ provides a standard library that allows basic OS operations, the immensely useful STL and a powerful stream I/O system with basic implementation for files and memory buffers. The Java core libraries go much further by providing classes for anything from data structures, to communications, to GUI. It is yet to be seen how C#'s system library would fare in comparison.
One thing that's sure to be missing from C#, and very sadly at that is any form of genericity. Genericity, such as it is implemented in C++, allows one to define "types with holes". Such types, when supplied with the missing information, are used to create new types on the spot, and are therefore considered to be "templates" for types. A good example of a useful type template is C++'s list, which can be used to create linked-lists for values of any type. Unlike a C linked-list that takes in pointers to void or a Java linked list that takes Object references, a list instantiated from the C++ list template is type-safe. That is to say, it would only be able to take in values of the type for which it was instantiated. While it is true that inheritance and genericity are often interchangeable, having both makes for a safer, possibly faster development platform.
The designers of C# have admitted the usefulness of genericity, but also confessed that C# is not going to support genericity on first release. More interestingly, they are unhappy with C++'s approach to genericity, which is based entirely on templates. It would be interesting to see what approach C# would take towards the concept, seeing as templates are pretty much synonymous with genericity at the moment.
To sum it upMany now refer to C# as a Java-wannabe, and there is much evidence to support this notion. C# doesn't only borrow a number of ideas from Java. It seems to follow up on Java's sense of clean design. It's a somewhat sad observation then that C#, purely as a language, not only provides a fraction of the innovation and daring that Java did, it also falls just a little behind Java where cleanliness and simplicity are concerned. However, if you're someone like myself, who uses Windows as their primary development platform and needs to use C or C++ because he cannot afford the overhead that Java incurs, it's possible that C# would turn out to be a very beneficial compromise.
I'm sorry, kids, but any language that is tied to a single OS - as C# is destined to be - is nothing but a scripting extension. I don't care how many bells and whistles the language has.
C was created specifically to emulate a "universal cpu" and to make it easier to write software across platforms. C++ extended that mission with the added benefit of reusable code (cross-application). C# is a step in the wrong direction if it pretends to be a language in the same class as others with 'C' in the name.
As far as I can see it's main innovations are little more than invisible methods.
--------
Yeah, I'm a Mac programmer. You got a problem with that?
-- thinkyhead software and media
Interestingly enough, this new language, "C##", has already been dubbed "D" by various industry experts.
(Note: Having to explain this joke means it is a great failure.)
Providing Thetan's(TM) safe-haven for over 18 years!
"I mean, what would be the advantage??"
There probably won't be a technical advantage, but MS seldom creates things because they'll have a technical advantage; MS creates things that give MS a strategical advantage. In this case, MS needed something of their own to tie into application development for their .NET "vision". .NET has the potential to make vast amounts of money for MS (that will make their current revenues look like small change) but they need as much lock-in as possible. If a whole generation of programmers learns C# instead of C++ and Java (just wait for the deals that MS makes with Universities, it'll happen soon enough: "we'll donate hardware to your university if you teach C# in the courses") then those developers are primed for .NET development.
Sure, MS could use C++ or Java for .NET, but then developer skills are general enough for those developers to use anywhere.
Of course, it could be I don't know what I'm talking about, because it's difficult to really tell what C# will be about, what with all the hype surrounding it.
> Now, Java uses mark-and-sweep in order to garbage collect.
No, it doesn't specify any such thing. You're perfectly welcome to use any collection system for Java objects you like, including high-performance generational/copying collectors.
As it happens, the bulk of Java implementations do use mark-sweep as part of a conservative collection approach, because of the need to interact with code that is not GC-aware. That's easiest to structure as a simple mark/sweep pre-pass to the real collection phase, which can do pretty much anything it wants that doesn't involve moving or freeing the conservatively blacklisted objects.
I have a GC library for C++ I've written which works exactly like this - mark/sweep conservative phase, generational copy collector phase - and works just fine.
As for the copy-by-value/copy-by-reference distinction, template library authors already make this distinction for performance (at least I do in mine) and provide simple ways to annotate classes so templates expand to by-reference versions. That said, the biggest problem with that is that even in MSVC++6.0, the template support is still so broken that you spent more time fighting internal compiler errors that coding :-(
Back to the article being replied to:
> Part of the uniqueness of C# is its conception of code reuse - for instance, instead of purchasing a commercial garbage-collector for your C++ code, you get one for free from C#.
Huh? It's "unique" to do something that most every programming language outside the Algol/Pascal/C family has done from day one?
> But where does this garbage collector reside?
It's in the language run-time, which can be wherever the implementation gives you the option of putting it. Y'know, like malloc ().
In case you've never seen one, a garbage collector is not a big piece of code - a simple but perfectly effective one is typically much smaller than the equivalent malloc () code. For high-performance allocator implementations (like the impressive Hoard from Paul Wilson's group at UTexas, where allocation performance of all kinds are studied), expect a GC and a manual allocator to be of roughly similar overall size and complexity.
The SDK preview includes a copy of the C# compiler with Win2k Professional. (Note that the SDK does not include the Visual Studio 7 preview, but it does include "ASP+, the Common Language Runtime, documentation, samples, tools, and command line compilers.")
Microsoft also has some public newsgroups (hosted on "msnews.microsoft.com") for discussions about the .NET frameworks, C#, C++, VB, etc. And DevelopMentor is also hosting a
.NET mailing list.
The August 2000 issue of MSDN Magazine is also featuring an article about C#.
As I'm not an experienced VM or compiler programmer, I hope you'll al forgive me if this is a stupid question, but here goes: If the C# VM is basically a slightly tweaked version of the MS Java VM internally, then wouldn't it stand to reason that another VM could be adapted to handle C# code? How unique is the design of their Java virtual machine?
Events are one example of how C# takes a popular use of pre-existing object-oriented mechanisms and makes it explicit by giving it a name and logic of its own.
Except that it already existed decades ago in Lisp under the explicit name of "closures", exists also in Python under the name "bound methods", and exists in general in dynamically typed languages under the idea of "protocol". The difference is, in C#, you have type checking, so you have to declare the signature.
Delegate is rather an example of how "Those who don't use Lisp are doomed to reimplement it." :-)
I think this whole "write in languages that are C, but easier" movement that's been going on for decades is a little weird.
Decades? The first real language to fit this description is Java. Pascal came before C, if that's what you're thinking of. Modula-2 and Oberon were after C, but they descended from Pascal, not C. Ada? It wasn't nearly as low-level as C, and had more modern features (e.g. packages). Objective C? That was a merging of C and OOP that went down a different path than C++.
Not sure what you're talking about here.
And there's the secret we've all been looking for...namely, why MS would go to all this trouble to create a Java-alike. Windows 2000! They need a way to strongarm developers onto the new system, and away from NT or 98. If the development tools are only available for Win2k, then you're going to have to upgrade if you want to stay ahead of the curve.
I don't know what your philosophy is, but I wouldn't want to tie my career to one company. Computer Science is not supposed to be learning the language of the day, but the fundamental paradigms and algorithms to allow you to pick up any language.
Though my personal preference is obviously Linux, in a pinch I could become a Solaris or Irix guy. With my UNIX background I can transition to NT easier than an NT guy could to UNIX. The tech world changes so quickly it is best to be flexible and to keep an open mind.
The way I feel right now though, I'd rather take a lesser paying job doing UNIX stuff and be happy than make more money doing MS and be miserable. Each to his own though. :)
The more you know, the less you understand.
Inheritance and Interfaces
Objective-C in the OpenStep/Mac OS X environment has single inheritance from a base class (NSObject), and protocols, which are precise counterparts to Java's interfaces. I have run into situations, however, where multiple inheritance is exactly what is required, and using interfaces meant that I had re-write the exact same code more than once, as I was implementing a group of specialized collection classes in Java. There were two axes of differentiation: mutability = (immutable, mutable), and ordering (partially ordered, ordered, strictly ordered). There was a lot of code that had to be duplicated that I should have been able to inherit from two abstract superclasses, one for mutability, and one for ordering. (*grumble*)
Garbage Collection and Memory Management
Objective-C provides a semi-automatic reference-counted garbage collection mechanism that is amenable to programmer intervention to increase efficiency, through a construct called an Autorelease Pool. Every object has a retain count, which can be incremented or decremented. The object's retain count starts at one, and when an object's retain count goes down to zero it is garbage collected. Note that this happens the instant that the retain count drops to zero, not during a mark/sweep. However, you may need to pass an object on to another part of your app, but your code does not need/want to retain it. What you do instead is tell the object to auto-release. It is then put into the autorelease pool, and later on during the system's garbage collection each object in the autorelease pool is sent a release message. Some objects that are entered in the autorelease pool still have a retain count (as they are being retained by other objects) and are simply removed from the autorelease pool; others have their retain counts drop to zero and are garbage collected.
You can fine-tune this mechanism to a high degree, by putting your own autorelease pool in the stack ahead of the system's primary autorelease pool. For instance, suppose you know that you will be allocating a whole bunch of objects for use in a part of your program, and after you exit you will never need them again. Well, you can put your own autorelease pool in for the system's autorelease pool at the start of that section of your code, write normal code, then remove and release your private autorelease pool and put back the system autorelease pool, which release all of the objects you created in your little section of code. Conversely, if you want an object to stick around, just don't ever release or autorelease it.
However, from a business standpoint, I find that the automated garbage collection and never having to worry about memory allocation issues is a strong point of Java. It allows me to code more complex applications and avoid memory debugging issues that invarable bedevil complex Objective-C and C++ programs. I can get a WebObjects application to a customer much more quickly using Java than using Objective-C, with quicker turnaround and more feedback cycles.
Events, Notifications, and Delegation
The OpenStep and Mac OS X operating systems (viewed separately from the Objective-C language, as these features are available from Java as well) have long had notifications and delegates. There is a system-wide notification center, objects can define notifications that they will post in response to certain events, and objects can register to receive particular events or classes of events. This mechanism has been in place for a long time.
Delegation is a bit more tightly tied to Objective-C, as objects in Obj-C can pass messages (i.e. method calls) onto to other objects, and objects can "pose as" other objects. An object can register to be the delegate of another object (in Java, the delegator object needs to make special provision for this), and there are "informal protocols" or "informal interfaces" defined that indicate the possible messages a delegate might receive from its delegator. Again, this is not new, and its assembly into a single OS is not new.
Primitive Types
This is one feature that I like very much, and wish that Java had. Objective-C, of course, will always have to support native types such as char's and int's, as it is defined as a superset of C. However, Java had the opportunity to remove this artificial distinction, and has caused lots of cursing from yours truly over the past couple of years.
Compiling to Native Code
I would point out here that compiling to native code may not result in the fastest execution. Review the HP Dynamo project, as written up on Ars Technica, for the reasons why JITC can actually exceed the speed of native code. The whole Transmeta Crusoe architecture is built around this theory of operation, and no one will claim that it's too slow.
Genericity
Amen to this. The fact that genericity is missing from Java is a serious gripe of mine, and the fact that it is missing from C# is a serious omission. This business of casting objects coming out of arrays is a pain the in neck, and it is often tough to find out where an object of the wrong type went into an array, although on the cast coming out you get a ClassCastException. Far better to catch the problem when the object goes in, which often gives you a better idea of where your design is broken. One of these days I am really going to have to start using the stuff coming out of the GJ project.
Conclusions
Overall, I find that the "new" stuff in C# is really old stuff. Furthermore, this is not the first time that all of this has been pulled together in one place. Almost all of this has been in the NeXTStep/OpenStep/Mac OS X family for a long time, and the implementations there are quite mature. I suspect that the implementations in C# will require several revisions before they reach the levels that programmers can really use.
Just so everyone knows, I am a Consulting Engineer working for Apple iServices, a part of Apple Computer, specializing in WebObjects development. These opinions are my own, however, and not those of Apple.
--Paul
I wrote a graphical editor in Java. On a 1024x768 display (modest for the times), the performance penalty of Swing made some parts of it barely usable on a dual P3-550 Xeon box with a TNT2.
This was not sloppy code. I made extensive use of caching, pre-rendering and Java2d to make the most of the platform. Java simply has performance overhead -- the overhead of Swing (sloppy, sloppy -- it's not even well built, consider for instance that affinexforms were hacked on but don't apply heirarchically and thus can't zoom Swing UI elements) is huge, but there is overhead in JAva2d (JNI is slow, especially for copying chunks of data back and forth) and some additional overhead in the basic design.
In Java, it is almost impossible to write cache-friendly code. If you build things in an OO fashion, you cannot force locality, since object refs force you to essenaitally chase pointers for every object. If you write degenerate code that isn't OO (sort of misses the point) then the array bounds checks hammer you anyway (and no, I have yet to see this eliminated by "smart compilers").
Java has some inherent problems with performance. These are real, they exist, and they are fundamental to the platform.
Consider that in JAva, you have to have a thread per socket connection. Yes, I'm serious. There is no select, there is no poll. This means that a messaging server on Java can maybe serve 3000 clients before it starts to fall apart, but something in C++? Trivial to serve 20,000. You don't even need to optimize it to get that level of scalability that even optimized JAva can't do.
Consider the weirdness that Java can spawn a child process but not attach to a process that's already running (easy to do in C [C++, C, C#]). How do you write a watchdog process in JAva whan you can't kill a process that's hung?
Java is great. I've used it extensively. But it is seriously warped in some ways.
RSR
Granted Java has an overhead, but it's getting better and better every release. 1.3 with the new VM, hotspot, is incredibly fast. I wish i still had the url of the benchmarking of it. It beat C++ in speed on a couple of tests, granted they were the recursion which C++ doesn't handle well, but Java is getting much better. C# is going to have to show me something besides the speed factor to get me to switch.
Casting from Object is not comparable to C++ templates. Firstly, you lose any compile time type checking (which C++ templates give you). On the contrary, the Java approach is the hack. Don't take my word for it, read interviews with Gosling where he admits as much.
Part of the uniqueness of C# is its conception of code reuse - for instance, instead of purchasing a commercial garbage-collector for your C++ code, you get one for free from C#. But where does this garbage collector reside? Is it in a shared library? If so, where and when does it get called? Is it a seperate process fork()ed off from the main process? Does the collector get compiled in to each and every program? Is it part of some system-level component that will be built in to the next Windows, that Linux will have to emulate? Inquiring minds want to know...
Free BeOS, runs from a Linux partition
From all the reviews I've read, "See Sharp" doesn't.
"History doesn't repeat itself, but it does rhyme." Mark Twain
You may not always be safe in C++. (Acrobat format ;)
___
__
Do ya feel happy-go-lucky, punk?
Other than that, you're just regurgitating the typical boring Slashdot opinion set in a highly overdramatic style. To call a language dangerous, a corporation evil and to literally identify a real manager with the PHB from Dilbert is at best inaccurate, and at worst displays a shocking seperation between you and reality. The world is not as black and white as you would like it to be.
--
It's a
-- Danny Vermin
Concerning the ASP+ stuff, though, there are a ton of things built in to increase performance. For example, current ASP pages are scripted... they are interpretted, an execution path stored in memory... when the cache maxes out, the plan for the least used script is dumped and if that page is visited again, it needs to be re-interpretted. ASP+, however, creates a "compiled" version and caches it to disk. (The compiled version is the bytecode in the .NET CLR.) For a good article on ASP+ be sure to check out this piece I wrote:
ASP+: An Introduction and My Views on the Matter
http://www.4guysfromrolla.com/ webtech/071500-1.shtml
Happy Programming!
I could not justify my existence if I were a turkey farmer. Would I terminate myself? Undoubtably, yes.
It might have something to do with the fact that a lot of us might have to learn this language.
--
It's a
-- Danny Vermin
http://cm.bell-labs.com/cm/cs/what/smlnj/
Many people I know here at CMU found ML tough to wrap their heads around. I think it is a wonderful language, and I plan on using it for as many projects as I can in the future.
Ben
From what I've seen in the C# Tech Preview SDK, C# does compile into an intermidiate language (IL), but it never actually runs as IL. Instead, the installation process compiles the IL into machine-specific code that is optimized for the specific platform its running on. Once the code is installed, the byte-code IL can be thrown away.
What it seems like is a cross-platform distribution but with native compilation upon installation. Sorta a best of both worlds kinda thing...
It should have been called:
C~1
Skinner: "We need a name that's witty at first, but that seems less funny each time you hear it.
Apu: "How about "The Be Shaprs?"
Skinner: "Perfect."
Homer: "The Be Sharps."
I could not justify my existence if I were a turkey farmer. Would I terminate myself? Undoubtably, yes.
How often do you hit Enter followed by Tab, only to realise that MSVC has already indented correctly for you? Yes! It drives me nuts. That's why I use the VisEmacs plugin for anything more than trivial editions. I keep the MSVC editor for when I'm debugging (which isn't really editing I suppose). This plugin is great. It's a god send.
There is Java Grande. These guys are working on making Java more suitable for number crunching and similar jobs. They've contributed to StrictMath and suggested the strictfp modifier (IIRC)... If they thought number crunching couldn't be done fast enough, they'd never started the project. It seems like the interpretation / just-in-time compilation part of Java doesn't have too much of an influence on performance with these kinds of applications.
Microsoft says it's supposed to be pronounced C (sharp). But I've almost always heard "#" called the hash mark. Regardless of what the PR folks say I believe that M$'s developers really meant it to be pronounced see-hash. Could this indication of an obsession with pot among Microsoft's developers be an explanation of the buggy history of Windows? I don't know but it does explain things...
credo quia absurdum
Heh. With all the work I do with shells and perl when I first read the language name I thought it would be read as "See Comment".
I wonder this very same thing everytime I start up a Smalltalk image to get some work done. So many of the "innovations" of Java and C# are naught but features of Smalltalk with C's nasty syntax applied. Then you have abonomations like C++. I'll never understand the motivation behind that. I usually chalk it up to the fact that the average programmer's brain isn't flexible enough to look at non-BCPL/Algol syntax. Sounds elitist, but I'm at a loss for any other explanation.
:)
Thanks for the pointer to Cugar- I've not looked at it yet, but hopefully I can use it to escape the hell known as C++ this coming school year... Bloody professors won't let me use Objective-C or Smalltalk, but I'll show them!
Working toward a usable PDA environment in the spirit of Newton OS: Dynapad
I've done extensive Java programming since it was v0.9, and C++ programming for about six years, and my opinion is that most of the OO stuff is complete mumbo-jumbo that only serves to confuse the core programmer and others who try using their code.
One rule that has served me well throughout the years is that one should never use a tool more complicated than the problem demands. Many OO programmers throw this rule out the window, and spend weeks playing with Factory patterns, polymorphism, huge inheritance hierarchies, and all sorts of other junk that creates bloated, useless code.
At the very least, C++ allows me to limit the amount of OO I introduce into programs. Java seems to be as retarded as Smalltalk when it comes to this.
Even for "internal" programs that don't require full-out performance, I can bang out a perl solution in half the code it takes a Java programmer do write. I have to wonder how Java programmers keep from going insane. The language and object hierarchy are so verbose that it takes at least twice as many lines of code to get anything done as any other language, and then the speed sucks. Rant off.
I see a lot of interesting issues being partially raised here, and by the original article.
There is indeed overhead involved in a reference, but the hope is that you only have to handle "large" objects by reference. Things like numbers are indeed "atomic" meaning that one use of the number 5, for example, cannot be distinguished usefully from another instance of the number 5. It doesn't make sense to say "change the value of 5 to be 6." Instead, we have a place that can hold numbers, and we change the value in that place to be the number 6 instead of 5. In that sense, a numeric variable is a "reference" to a location in memory, which can contain "values" although we never use those terms in C, as there is no pointer indirection or overhead involved.
Now, the problem comes in when you talk about larger things, like, for instance, a 3-D rendered scene. Say I have a "scene" which contains a bat and a ball. If I "duplicate" the scene, so I have S1 and S2, and I move the ball in S1, does it move in S2? Hmmm. It depends on what you did/meant when you "duplicated" the scene. Is it the "same" scene, meaning you scratch one and the other bleeds? Or is it a new scene, which just happens to look the same? The same philosophical problem arises when you pass parameters to functions. Do you "duplicate" the argument, or not?
The point is that a language implementation pushes bits and bytes around. However, a programmer is managing abstractions, and the handling of those abstractions CANNOT be specified as part of a language definition! It depends on the programmer's intent!
This is another mess that C++ got into when it had to manage assignment and initialization of classes: "copy" constructors for all your classes. But what does it mean to copy? It depends! Not only does it depend on your class, but it also depends on how you want to use it, which can change!
A side effect of this is that passing arguments around can involve a lot of excess "copying," if you insist on "copying" arguments before you pass them. C++ has to do this, because C did, except when you specifically ask for references. Now, if you have garbage collection, all these excess copies, most of which are soon discarded, need to be cleaned up.
I guess this is why the author here worries about garbage collection in his phone number instance. In principle, once you have everyone's phone number, you don't need to allocate any more of them, and unless people go away, or change phone numbers, you don't really need to throw them away. Unless you are in C++, so you have to keep "copying" them onto scraps of memory to send to subroutines, and then discarding the scraps as soon as it returns.
As a side note, mark-and-sweep is usually the worst possible garbage collection algorithm. You have to look at everything, even if most of it isn't garbage anymore. Much better is "generational" garbage collection, which mostly looks at recently allocated stuff. The idea is that if stuff has been held onto for a while already, it probably is still being held onto, while it is very common for things to be allocated, used only a little bit, then discarded. This can be very efficient GC.
The problem with people's perception of GC is that it happens behind the scenes. "malloc()" and "free()" are right there in your face. In fact, they have so few characters in them, "they must be fast." Of course, as soon as you fragment your arena, malloc can get slower, and slower, and slower....In Windows, where programs typically don't live long, you don't see this. But in the world of serious applications, if you want your program to run for weeks or years, this can be a real problem. Garbage collection on references can then be MORE EFFICIENT than manual collection, not only because it doesn't "forget to free()", it can also, when dealing with references, rearrange memory to be more compact, and therefore localized for cache issues.
Of course, I don't think C++ or C# garbage collection can actually do this, because when you move objects, you have to go back and change all the pointers that pointed to it, which in Lisp is easy, because the machine can tell a pointer from an integer, but in C-based languages is hard, because pointers and integers are both just piles of bits. But hey, that's what you get for programming in object-oriented portable assembler.
You obviously don't use Emacs as your editor.
Re-indent the whole file
M-<
C-space
M->
C-M-\
Emacs was designed for using with Lisp... now that's a language with crazy matching of brackets. Everytime I close a brace, paren, etc, the cursor shows me where it matches, or outputs the line in the mini-buffer. If I felt like it I could also have it automatically highlight the whole region between brackets. Really, bracket matching is irrelevant.
Personally I think that people who code in C/C++/Java/etc without using any braces for one line blocks are bad programmers. They're just asking for a bug to be introduced at a later date. Hence I don't do, and neither do a lot of the people I've worked with. It's just lazy.
I kind of like the braces (opening brace on a new line please) as it helps space the code vertically and provides an easy way to search for the end of a block (I'll leave coding for a 25 line screen to Linux kernel people and their crazy coding standards - bunch 'o masochists that they are!) I don't know how you would do that if the block was specified by indentation.
Go off and download the .NET SDK @ http://msdn.microsoft.com/net/...
I could not justify my existence if I were a turkey farmer. Would I terminate myself? Undoubtably, yes.
Well, according to INTERCAL notation, which I'm sure we're all familiar with, it's a "mesh". :)
It's no surprise that it sounds like Delphi! It was, after all, architected by the same guy who architected Delphi...
I could not justify my existence if I were a turkey farmer. Would I terminate myself? Undoubtably, yes.
I work with C, Java, and Perl all the time. I shy away from Java for most major apps though because its a HUGE memory hog and incredibly slow. However, I use it over C++ (when I can't use C easily) because of the elegant design and garbage collection sacrificing speed. This Napster guy makes a point about a speed increase because of the use of copy-by-value and also talks about how cool it is that an "int" is an object. How is this good? If every object is unique, then copy-by-value is good, but the second you have a duplicate, you start eating up memory. An int may only take up one or two bytes of memory in C, how much is an Integer class going to take up in C#? For something as large as the phone database he mentions, thats a lot of wasted space. To me, it looks simply like a fully compiled, less elegant, single platform version of Java. If Microsoft wants to do something, improve the Java VM, don't waste time on languages that are going to be used regularly by five people in the world. ( See ADA, Eiffel, Lisp ) -gtaluvit (prnc. GOT-ta-LUV-it)
- gtaluvit (prnc. GOT-tuh-LUV-it)
Mind you, this is one of Napster's programmers - the company famous for "taking existing filesharing software and making it work with MP3s" - about on a par with Baby's First JavaScript.
--
It's a
-- Danny Vermin
Of course, Microsoft isn't exactly the only group doing this. As much as I may like the looks of OS X, the development environment is, once again, highly dependent on a number of proprietary, platform-specific libraries and services. Linux and the rest of the UNIX-esque system benefit from the basic POSIX standard, but I think what we're seeing more and more lately is that that's not quite far enough these days. If the UNIXes of the world can't come up with a system that's as brainless to use as Visual Basic, Microsoft will continue to lure developers who can't, don't want to, or don't need to learn the intricacies of OO, and just want to quickly build applications with the benefits of pluggable components.
I don't know enough about C# to judge yet, but it's clear that you aren't taking a thinking-persons stance here.
.Net runtime engine. He has also said that the language will be submittes to ECMA, so you can reasonably expect runtimes to exist for other platforms.
Let's deal with your points 1 by 1.
1: It's been shown a few times that incremental languages are successful and revolutionary ones aren't. C++ was incremental on C. Eiffel was revolutionary. Which is in greater use. Leave the revolutionary stuff to experimental languages but be clear that ideas extracted from those languages and implemented in a incremental way are ideas that are successful.
2: Schizo Gerbil. Jeeze - get a grip. Does C++ keep all semantics the same as C? Nope. Does Java?
3. Non-open runtime. Really you don't know because the language is not ready for use yet. However Anders has said that the lnguage and all the other MS languages will compile down to run on top of the
4. No real standard. They have said they will submit to ECMA.
Get some balance dude.
As programmers, I think our next big challenge is to remove the inherent religious problems with "whitespace" in programs entirely, by presenting a programming system where the programming is truly done at a conceptual level, and not at a textual level. Pick UML, or (relatively) standard flowcharts for procedural decompositions, and work graphically. Initially, you could "render" your program in a variety of back end languages (c, c++, java, perl, tcl, python, etc.) for execution. Eventually, you could generate machine code directly, libraries for "packages" and binaries for executable programs. Then all we can complain about is the expressivity of the graphical programming environment, and not meaningless trivia like syntax, whitespace, and so on.
How's my programming? Call 1-800-DEV-NULL
I've used GJ quite a bit, and I'm quite happy with it. Furthermore, there's reason to hope that code written in GJ (the syntax of which is similar to C++ templates) will be compatable with future versions of Java, since Sun is looking into adding genericity to Java, and looking at GJ in particular.
Personally, I avoid all of this by using the C indentation mode in Emacs, where "tab" means correctly indent the line, not insert five spaces, so I can quickly check for errors like those by hitting tab on each line.
(Right now I am teaching myself Visual C++, and the hardest thing about it for me is getting used to MS's editor, not the syntax!)
LL
"If you are falling, dive." -Joseph Campbell
The parent post was making lots of sense until I read this bit:
Since it does things like treat "=" as comparison in conditionals and assignment in statements, as well as the whole whitespace formatting thing, it totally spoils you for writing in things like C and Perl.I'm sorry, but that is just not true. In Python, '=' is assignment and '==' is comparison, just like in C, C++, etc. What you cannot do is do an assignment and simultaneously treat the rvalue as a boolean in a conditional. In other words, if you mean to do this:
if a== 6:
print 'a was 6'
If you had you accidently typed this:
if a = 6:
print 'a was 6'
Python stops with a 'Syntax Error' exception. If you make the same mistake in C, if would happily overwrite the previous value of a and print a was 6. Lots of fun to debug .. not!
They had a look "under the hood" of the Virtual Machine only to discover that it looked *strangely* just like MS's Java VM. Apparently they changed the variable/function names but the programmer who was taking a look said the code itself looked the same. They commented that they could actually run Java code on the system without problems, providing it didn't refer to any of the special Java class libraries.
.net is NOT the same as the Java VM; it's not even the same codebase. It was a completely different team who didn't use any of the JVM code.
Uhuh... right...
The runtime for
Simon
Coming soon - pyrogyra
Perhaps the more fatal flaw is that you refuse to touch it because of that attribute (significant whitespace). While Python isn't my favorite language (for other reasons), the whitespace-as-syntax has never been a problem for me or the other Python programmers out there. In fact, I've yet to talk to someone that hates the whitespace-as-syntax whose actually done more than go through the tutorial and a couple trivial scripts. Try it out for a while before you write it off as a design flaw.
Working toward a usable PDA environment in the spirit of Newton OS: Dynapad
The JVM is not required to do mark-sweep GC. The JVM spec ifically leaves the implementation of storage management unspecified.
This is good because it means that Java can use modern, higher-performance GC strategies like stop-and-copy or generational GC, both of which have been in use in Lisp and Scheme systems since the 1980's. I strongly suspect that C# will have to use mark-sweep or some other non-relocating GC, since you're allowed to go down below it to assembler, exposing pointers that might need relocation.
Do most JVM implementations really still use mark-sweep GC? Despite James Gosling and Guy Steele both being ur-Lisp hackers?
To a Lisp hacker, XML is S-expressions in drag.
It is interesting to note that two of the "new" things that make the article author so excited have already been done ny Borland, in C++Builder, while retaining C++ compatibility. (Well, okay, they added a couple keywords, but marked them as implementation-dependent using the ANSI standard double-underscore prefix.)
... an object reference as well as a method reference.
Personally, I found C# support of events to be a very exciting new feature
C++Builder has been doing this since day one, with what Borland calls a "closure". You use a new keyword, __closure, to declare a pointer which points to a member function of a specific object instance. Not surprisingly, Borland uses this to drive the entire event system in their GUI framework. It rocks.
Properties are another example, even though they're not as much of a labor-saver as events are.
Again, Borland has been doing this since day one. The keyword __property can be used to declare object members which appear to be simple variables to "outsiders", but do magic when read or set.
Once again, Microsoft fails to innovate, but instead steals from elsewhere.
dragonhawk@iname.microsoft.com
I do not like Microsoft. Remove them from my email address.
HotSpot is *extremely* good.. probably a fair distance along the way to optimal, given its ability to do things like deep inlining across several layers when the runtime history indicates that path is very hot. The reason Java code still runs slower than C++ is partially due to the HotSpot overhead and partially due to the fact that the way you write code in Java is often much less CPU efficient than if you were to write code with similar intent in C++.
In C/C++, you would parse a file line by line by constantly re-using a single memory buffer for each line of the file that you read (sizing it up if it overflows, of course). In Java, since Strings are immutable (for thread safety), you wind up creating a new String for each line, plus a new String for just about every subelement that you pull out for further processing. This sort of style is mandated by the fact that so much of the Java class library API's demand real live immutable Strings, and you don't have a choice but to create a bazillion of them in many cases.
With HotSpot, creating new objects off of the heap can be very nearly as fast as stack-based allocation of auto variables in C/C++, but it's just not going to ever be as fast as intelligently re-using a memory buffer. There are many things in Java programming that force that kind of trade-off. The benefit is that you get a lot of aid and encouragement to make your code thread-safe and that it is actually possible to guarantee that an object's private state can't be trashed by anything external to it, never no way no how. A completely reasonable trade, in my opinion, especially in light of the massive portability support provided by Java, but it's not The Answer To Everything, of course.
But HotSpot itself is some impressive shit.
- jon
Ganymede, a GPL'ed metadirectory for UNIX
So is it feasible that I could define an object in C# that fires a ReleaseMe event when it's finished with itself, at which point it gets garbage collected?
; -- the corruption of government starts with its secrets. a truly free people keep no secrets. --
As for JITC, prospective apostles of this technology should try it out with real programs and do extensive benchmarking - indications are that HotSpot is still two to four times slower than C++. Most claims I have seen for JIT code is based on in-memory operations with very little IO and/or user-interaction.
What's hearsay? My comment or the other guy's?
.net team? (Clue: Not him).
Which of the two of us worked on the
Simon
Coming soon - pyrogyra
That's right except for a few things:
the output would be "21" and "10" if it is passed by reference, not "10.5" (integer division)
C and C++ pass by value by default, and Java passes primitive types (int, double, char) by value, but Objects by reference
There's a C library that does garbage collection already. Actually, I think there are a few of them.
And it's a shame to not see good template (genericity?) support in C#. Or any language, for that matter.
I think choosing a good type system is where a lot of languages fall flat, and I'm not a big fan of the huge C++/Java Object/Type/Library approach, although I haven't seen a truly good solution to this problem yet. C, Pascal, Java, Perl, Scheme... They all have different ideas and solutions, and I haven't seen a "Right Way" yet. Although I think Scheme has the right idea with its first class data types, it still all needs some work.
---
pb Reply or e-mail; don't vaguely moderate.
pb Reply or e-mail; don't vaguely moderate.
Events? Attributes? Garbage collection based on copy-by-value?
The similarities to Visual Basic are eerie. It sounds a lot like they looked at the way people were using VB and incorporated those ideas plus improvements people have been asking for into a package that is more 'programmerly'. Anyone want to place any bets that this is the heir apparent to VB?
I would argue that efficiency and performance are more likely arguments for C.
(Eiffel, Haskell, ML come to mind)
Haskell in particular is cool, but I think you do these languages a disserive by mentioning them in the same post as Java - while they all require a new way of thinking, none of them has nearly as much mumbo-jumbo associated with them as Java. In fact, I see the simplicity of Haskell as its key advantage.
I found the comments made about this language feature in the article somewhat naive. It is well known that C++ templates, being pure textual substitution, do not guarantee type safety. For examples, see "Object Oriented Type Systems" by Shwartzbach and Palsberg. In that book, you can also find a viable alternative (and a nice proof that inheritance and genericity are orthogonal mechanisms which commute). Matt
"For serious number-crunching, using JNI to hook into some optimised native libraries, which can be built with a minimum of platform-dependant code if you don't count Makefiles, all-but-negates any speed loss that going with a purely Java solution would give you."
I've always been partial to CORBA as a solution to using native components. It doesn't matter where and how your components are implemented. We were doing stuff using the TAO ORB for our C++ servers (and Visibroker in Java). For what we were doing, CORBA is so fast that it wasn't really noticeable if my CORBA servers were at the other end of a dial up connection!
that one design flaw (making whitespace significant) has kept me from wanting to touch it. It would be okay for the compiler to generate a warning for incorrectly-indented code, but to generate incorrect code instead is simply inexcusable.
/*d'oh!*/
I think this is a common poor analysis that reads the situation backwards. In reality, code is almost always indented "correctly" according to what the programmer intended, errors arising from incorrect indentation are generally due to the programmer failing to insert the braces in the correct positions, and thus don't exist in a language like Python. So "to generate incorrect code" due to a formatting error is simply an impossibility, unlike in C.
Whitespace formatting is instantly visible, that's why people indent their code even when it's insignificant. Braces, OTOH, are very hard to keep track of. When the whitespace isn't used by the compiler, that means you're using one technique to give this information to a human reader (including yourself), and another to give the information to the compiler: a sure recipe for errors.
How often have you seen C bugs due to missed semicolons and braces? Part of this
if(x==y)
doxeqy();
Then you realize you had to do more for that condition:
if(x==y)
doxeqy();
doyeqx();
Whoops! It looks okay, but of course it's not.
Or how about this classic mistake?
if(x==y)
if(t==u){
doxyandtu();
doxyandtu2();
doxyandtu3();
}
else{
donotxy();
}
Hmm... looks okay, compiles fine...
Sure, they're goofy mistakes, people make them all the time! Human minds are terrible at diligence tasks (when they have to remember to do something and nobody is reminding them to do it). Of course you're going to forget to put in braces sometimes! Why not design the language so your first impression is always right?
In practice nobody ever fobs up a Python script with something like:
if a=b:
if c=d: do_aeqb_and_ceqd1()
do_aeqb_and_ceqd2()
It's immediately apparent from the indentation that the second function call is in the "if a=b" block, not the "if c=d" block.
However, I do think that pushing Python as a teaching language is a terrible mistake. Since it does things like treat "=" as comparison in conditionals and assignment in statements, as well as the whole whitespace formatting thing, it totally spoils you for writing in things like C and Perl. Even experienced C programmers often forget things like semicolons and mix up comparison and assignment, people moving from Python to C just have a terrible time.
---
Despite rumors to the contrary, I am not a turnip.
I think this whole "write in languages that are C, but easier" movement that's been going on for decades is a little weird.
t -level language". If I was looking for ease of use and didn't care about optimizing, I'd go with PERL, or, hell, even Quickbasic.
If I want to use a medium-level language because I want absolute control and optimized speed, I'll use C. I don't want an "almost-medium-level-but-a-little-higher-than-tha
Granted, there's a need for these "weird-level" languages, and some people love them - but I think that C++ and Java nicely fill the niche. So, my first thought, which is even more valid, I think, in the face of this review, is "Why does Microsoft feel almost obligated to make an M$ version of *everything*??"
For GUIs and money managers and anything else aimed at "my mom", Microsoft is guaranteed to reign supreme, because "my mom" doesn't really care about performance issues or security or any of that. But my hunch is that, in light of some of the bugs and general ickiness covered in this review, few people are going to want to switch over to C#. I mean, what would be the advantage?? If you already write C++ and/or Java, why would you want to start writing stuff in C#? I just don't understand.
"Beware he who would deny you access to information, for in his heart he deems himself your master."
Why do we need yet another object-oriented C? We already have C++ (fast but crappy) and Objective-C (slightly slower but way better), what does this C# thing add? I saw no compelling features in it that Obj-C doesn't already provide.
Mod down posts with a "Free Mac Mini/iPod" sig, they're spam!
(I know I'll get thrashed for this, but my karma can take it)
.NET ties which only exist on Windows, is in part a tactical method to inhibit migration of Windows products to other platforms.
It seems to me that creating a new 'standard' language, which neverltheless relies heavily on COM and
Let's say that C# is simply a better language to program for Windows than C++ is. Let's also suppose the hypothetical case where new Windows functionality comes along in future Win versions, and that this functionality is more easily taken advantage of using this new C# language. This gives developers the incentive to code new Windows products in C#. Note that C# has substantially different enough structures that porting from C# to C++ would not be trivial.
Now suppose that Linux (or another OS) starts gaining prominence in the next 2-8 years. As with any new OS, its main barrier to entry is lack of software. (The only reason Linux is viable is because of all the UNIX software it inherits.) In this time, Microsoft's pushing of C# has created a new software base for Windows that is relatively locked into place, unable to be ported to other platforms without significant effort.
Now I'm not saying this is evil. I'm not saying it's a conspiracy. Often languages built for specific environments are superior tools in those environments specifically because they're specialized.
It's just something to be aware of.
Kevin Fox
Kevin Fox
I agree, C# does not provide much new. The only nice thing I could discover in it was the delegate function. The syntactic sugar in the rest of the language may also be convenient but won't save much time since it does not fundamentally change the way you model a program.
Right now there are two things that I would like to see in a new OO language:
- templates (not the crappy C++ version)
- aspects (as in AspectJ)
Both make it significantly easier to model certain problems. Especially aspects are really cool. Unfortunately C# provides neither which dooms it as obsolete even before it is finished.
I don't think C# is a bad thing, I just think it is not a very big step forward (to small to be interesting).
Jilles
True... "corporatism" was invented and employed to pad out Jon Katz articles (which generate web hits to sell ads); totally different.
Information wants to be anthropomorphized.
I agree, the JIT does a great job for performance, but the gcj is more along the lines of what I'm looking for in a Win32 environment.
Providing a self-contained executable, or a set of compiled files (a'la DLL and EXE) is much easier than making sure that a customer has a servicable JRE on his/her box. As it stands, dealing with distribution of Java programs is just as bad, if not worse, than handling VB programs. With VB all I had to worry about was providing the correct VBRUNxxx.dll, but with the recent (relatively, you must admit) switch to Java2 and the more recent addition of HotSpot in JDK1.3, things got complex.
Distributing the complete JRE each time, Just In Case, isn't going to cut it. Yes, the support stuff is in JARs, and these can all be conditionally installed - but that's a bit more to worry about than with an old fashioned EXE. Also, the fact that invoking a Java program involves not only starting the interpreter/JIT, but also setting a CLASSPATH, makes things icky - at least until Java makes adequate inroads that a CLASSPATH can be presumed. Sure, setting up a batch to do this is fine, but we're just compounding assumptions at that point. A binary executable is a lot more workable when doling out software to non-programmers.
-- What you do today will cost you a day of your life.
After all, Java does support the final attribute on both methods and classes, and JVM's like HotSpot are perfectly capable of doing extremely aggressive inlining as necessary.
Since Java is a late binding language, you do have to have some intelligence in the JVM to optimize the method resolution when new classes are loaded and compiled, so you still have to pay the link penalty for both virtual and non-virtual Java methods at the time that a class is loaded, but Sun's JVM on Solaris, Windows, and Linux will do the code rewriting during execution to translate final method calls to direct calls without any vtable. I believe it may even be able to optimize virtual methods to direct calls in circumstances where the execution history forces the object pointer to be of a specific type, as in the case where you have a line of code that creates an object of a given type and the next line you call a method on it.. since HotSpot could reasonably tell that at that point in the code that object reference will always be of the specific subtype that was just created, it would be able to just do a direct jump to the method.
I'm speculating here somewhat.. HotSpot may not be quite that smart, but Sun's comments strongly suggest that it does do that sort of path analysis for heavily used code segments.
- jon
Ganymede, a GPL'ed metadirectory for UNIX
It has almost the speed of C, a good Unix library, bindings for all sorts of graphical environments, etc. It isn't SML, but it's great!
In all talks about C#, IL is really the key - it's the intermediate language that all languages going to the .Net platform (including C#) get compiled into, before they are JITted on the target machine and run alongside the CRL (a support library).
Why is IL the key? Consider:
They are going to submit C# the language as a standard - but I don't think that includes IL. That means that even if you make a C# compiler based on the standard, they could change how IL is structured to shut you down.
They have stated IL will be compiled to native code in one pass. That can happen before it's deployed, or on the target platform. But by doing that, they loose the possibiliy of dynamic optmization (one of the things that makes HotSpot fast, and better than just a straight JIT). By allowing the compilation to happen before deployment, you also risk a bad choice for target platforms and possibly reduced performance of distributed components.
It effects all other languages. Using Visual Studio, pretty much all languages will compile into IL. That means the workings of IL affect your code to some degree, really regardless of language.
C# is an interesting language, and I like some of the features - but for all that, would it be impossible to compile C# to Java bytecode? I don't know the answer to that myself for certain, but really the development and capabilites of IL as a platform are really more interesting to watch than whatever language is on top.
Another interesting question to consider - C# allows you to have native (unprotected) code blocks. How does that work in relation to IL? Does the code get bundled with the IL, to be compiled when the IL is compiled? Or are the native parts compiled to native code when the other code is compiled to IL, and transported as a mix of IL and native code? The answer has some implications for optmization of native code blocks.
"There is more worth loving than we have strength to love." - Brian Jay Stanley
What is the difference?
P.S. I'm only 12, so take it easy on me.
Java is cute, but what do you do with it once OO becomes passe? (don't be shocked by this - there is actually a vocal constituent of clued in folks who are actively protesting the usefulness of OO).
I refuse to latch onto any language that forces me into one paradigm.
Its interesting - if you look at these languages in a detailed and discerning manner, you really get to see the genius of Stroustrup.
Read some of his papers on C++, perticularly his assumptions for the language, and you really see how far ahead his thinking was.
- Java uses mark-and-sweep in order to garbage collect.
Not always. There are other approaches used, depending on the implementation.This begs the question: since C# is tied to an implementation (COM), what's the likelihood that there will be competing implementations? On Windows, you have Java implementations from Symantec, IBM, Microsoft, Sun and even an open source one, Kaffe.
How many C# vendors do we expect? GNU C#? When you can't run it on a GNU operating system? Yeah, right.
...and C# relies heavily on Microsoft's Component Object Model...
Which is probably how most of this functionality (encapulation, events and call-backs) will be implemented. I'm getting the sense this is going to turn out to be something of a quazi-language, which was in the end what Microsoft's Java implementation became (Just try and do something meaningful in it without invoking a COM object.)
In the end, C# really does not seem to offer anything meaningful that VB does (or will) not, and for the same reasons will not be any less portable.
someone like myself, who uses Windows as their primary development platform and needs to use C or C++ because he cannot afford the overhead that Java incurs, it's possible that C# would turn out to be a very beneficial compromise.
If I'm already coding for a Winblows enviro, I already have C++. I damn sure am not switching to some new, barely supported language just for the "new toy coolness" factor.
Live to be Moderated
Some friends at work recently got back from a MS Developers Conference where they handed out CD's with Visual Studio 7.0 beta and a full version of Windows 2000 Professional (since Visual Studio 7.0 will only run on Windows 2000 Pro.) I loaded it up, read throught the C# book that was included, and was impressed.
C# is highly typed, so you don't spend hours looking through code trying to find a type mismatch.
It is early binding instead of late binding, meaning it is quicker! With Java (late binding), a file search and enumeration of 8000 files on our servers here at work took an hour and a half, and 50000 files with a C(early binding) app took 4 minutes, so C# takes the best of both. Also, because it is early binding, you don't have to worry about references to non-existant objects, when you are using DLL's for instance. C# automatically loads and reviews the routines contained in a DLL automatically, before compile, so a reference to myDLL. will bringup a popup list of the routines availible in that DLL.
Very cool stuff! It will be interesting to see if it takes over as the new, trendy programming language of 2000/2001, as Java has been for a few years.
And that's why I'm sticking with C, C++, perl, PHP, sh, and learning Java.
Q:Doctor, how many autopsies have you performed on dead people?
A:All my autopsies have been performed on dead peop
UNIX people tend not to pay enough attention to Microsoft's middleware layer because the UNIX world doesn't have that layer. (de Icaza is trying to fix that, but it hasn't happened yet.) Much of the success of Windows is due to that middleware layer. Note how strongly Microsoft reacts to threats to that layer, such as Java and Netscape, while Linux is regarded more as an annoyance.
Does anyone who got a beta of the Visual Studio.net from the MS PDC have any idea on how this performs? I mean, its taken Sun several years to come up with a decent performing VM for Java, and the CRL for C# sounds like it may have similar issues (despite the fact they claim everything runs as native code). If there are substatial performance imporovements from Java, that would definitely be another reason to move toward C# development (the Everything is a COM object is pretty slick too).
I think its interesting that the author of the article says C# has garbage collection like Java. I mean, wasn't LISP the first major language to have garbage collection?
DrLunch.com The site that tells you what's for lunch!
May I suggest Oberon? It meets all of what you're asking for -- and is a good language.
;-).
Its (optional) portable binary format is sheer genius.
Of course, I use and like Python, so my judgement is suspect at best
-Billy
I always use hard tabs. In fact, I require them in cugar. Indenting one space further than the previous line means a continuation of a previous line. Indenting more than one space is an error, because it could be misinterpreted as a tab. This forces consistent indentation on all cugar users.
Different people prefer indentations between 2 and 6 spaces (I like 3), why not let them choose? You can always change the tab stops in your editor.
---
Despite rumors to the contrary, I am not a turnip.
With Kylix bringing many of these features to Linux soon, as well as the strength of the VCL and a powerful rad tool that will provide an easy migration path, why is C# a big deal?
--sugarman--
Hate to say it, but some people enjoy using Hungarian notation in C++ programs to. There's no accounting for taste I guess.
I'm not a fan of Hungarian notation, personally, although I can see some value in it. For me, the impact on readability makes it not worth using. This is one of those classic debates, like vi vs. emacs, which will probably never be resolved.
If anyone is looking for a free software project to write, it just occurred to me that a missing tool that could be useful would be a program like indent that would add or remove Hungarian-notation prefixes instead of adjusting whitespace. I'd probably write this myself, if I were a fan of Hungarian notation. Since I'm not, I'm tossing the idea out there; maybe someone else out there wants to run with it?
Deven
"Simple things should be simple, and complex things should be possible." - Alan Kay
I think C# is closer to Amiga/Elate than Java. Java was designed with security as a top priority. i.e. being able to run in a sandbox. This imposed a number of limitations that effect java's speed performance. C# allows you to write "unsafe" code if you like, whereas Java requires you to load some external C library. By unsafe, I mean doing unsafe typecast and accessing memory you probably shouldn't.
.NET
Also C# never runs under emulation or interpretation - it is always compiled to native code before it is run. This is similar to how Elate works.
For comparisons based on my limited knowledge see here:
Elate versus
I discuss the IL assembly that c# generates more than the language c# itself.
--
-- Virtual Windows Project
ML efficiency is always a concern, but most modern compilers will turn simple recursive functions into loops (in fact, tail recursive functions running in constant space is part of the definition). The speed of compiled programs is getting much better, almost to the point where it's not worth worrying about (unless you're writing Quake 4).
You can declare variables in ML (or other functional languages), just not change them (they're math "variables" not programming variables). Most programs are (surprisingly) much more clearly written this way, once you get used to it. If you want updatable values, though, that's there too.
Parametric polymorphism is in C++ (templates), but it's done badly. Generic Java (and probably the next iteration of Sun's Java) will have parametric polymorphism that's a little more sensible.
Other features I find myself pining for when I'm not allowed to use ML: higher-order functions and proper closures; type inference; call with currrent continuation ("callcc" or "first class continuations"); lightweight threads and typed channels; roll-your-own infix operators; pattern matching; value-carrying exceptions that actually work; and garbage collection.
Firstly: yes, Swing is a bit slow (i haven't used 1.3, so i can't comment on that); this seems to be mostly due to rather dim implementations (using the win32 GDI rather than DirectDraw, not using hardware acceleration, etc), which will get fixed in the not-too-distant future. I have to admit that Swing is an embarrassment to Java: by far the most slow and buggy package.
Secondly: cache locality? I'm sorry to see that you know nothing whatsoever about modern OO compiler research - it's fascinating 8). There were some lovely papers in an ACM SIGPLAN bulletin a while back on just this; you can build a VM that tunes memory layout to improve locality, eg by clustering objects which are accessed together (only possible if you have a sophisticated GCish memory model, like Java) and splitting up objects so that the hot parts are clustered together (where they can get cached) and the cold parts are somewhere else (only possible if the VM has control over the code, as object splitting requires code rewriting). I don't think any of this research has made it into production VMs yet (we're also waiting for funky new GC strategies), which is a shame.
Thirdly: sockets; guilty as charged! The lack of asynchronous IO in Java is a crime. JSR-51 is sorting out bringing it in, but i don't know when it will make it into the releases. Saying "use a real operating system!" is not an answer, by the way - passing the buck doesn't help Java and doesn't help Java programmers (except that maybe Sun will sell more boxen, make more money and invest more in Java ...).
Actually, If your interested in type system stuff you should really check out Haskell. Haskell is a lazy functional langauge (ML is strict), so things do not evaluate unless they are needed. This means no lisp/ML style cheating with side effects to do IO. Instead Haskell uses a type system construct called monads to allow for IO, variables, side effects, and OOP. Actually, monads are really the best resolution to the apperent conflict between object oriented and functional programming. the monads have evolved far enough to allow you to simulate an imperitive object oriented langauge within Haskell.
:)
Anywho, Haskell's type system pretty much blows most langauge (including most functional langauges) out of thge water. The types for essentially every variable are derived from the contex where the variable is used, but there are still really nice systems for overloading / signatures / interfaces, type parameters, and type derivation.
It's possible that ML has caught up with Haskell's type features, but there are some interpreted varients of Haskell (maybe Gofer) which have crazy type parameterization by parameterizable type features (or something like that.. I forget). I think they have a type system for types (called kinds) to allow recursive type definitions or something insane like that.
Really, Haskell is one of the most fun langauges when you enjoy this sort of shit. I hear rummors you can use it for practical stuff too, but I wouldn't know anyhting about that.
The Christian religion has been and still is the principal enemy of moral progress in the world. -- Bertrand Russell
ML has an excellent implementation of parametric polymorphism (sometimes thought of as "templates"). You can define a function that counts the elements in a list of anythings:
fun length nil = 0
| length (h::t) = 1 + (length t)
which has type: 'a list -> int
(meaning the function takes a list of anything, and returns an integer).
Through the mechanism called "functors", you can specialize a generic structure (say "sets", or "mappings", or "arrays") with some types and operations to create a new type. Signatures let you make these types truly abstract (paired with type safety, a very powerful notion).
All of this is type safe (with proofs). Most of it is accomplished statically too, so there's little run-time overhead. It is indeed scheme with "some work".
One interesting way in which C# deals with the performance issues involved with automatic garbage collection is that of allowing you to define classes whose objects always copy by value, instead of the default copy by reference, which means there is no need to garbage- collect such objects. This is done, confusingly enough, by defining classes instead as structs. This is very different from C++ structs, which are defined in exactly the same way; C++ structs are just classes where members are public by default, instead of privately.
One new feature that I mentioned already was that of copy-by-value objects. This seemingly small improvement is a potentially huge performance saver! With C++, one is regularly tempted to describe the simplest constructs as classes, and in so doing make it safer and simpler to use them. For example, a phone directory program might define a phone record as a class, and would maintain one PhoneRecord object per actual record. In Java, each and every one of those objects would be garbage collected! [snip] In C#, you'd be able to avoid all this by defining PhoneRecord as a struct instead of a class.
I'm a bit confused.
If I follow this correctly, it's implying that C# is faster (in this instance) because you don't have to mark/sweep through all of the objects allocated in order to garbage collect all of the objects. They've been copied by value, not by reference, so you don't need to hunt down all of the references.
Doesn't this only work, however, if you're actually copying the objects? If I allocate several thousand PhoneRecord objects, but don't assign one to another, wouldn't C# and Java be equivalent in the speed of garbage collection?
It seems like this particular benefit of C# is only useful in a limited number of situations. I can't honestly say that I've ever really needed to create many thousands of objects in Java or C++ by allocating/cloning an existing object each and every time.
Can somebody confirm that this is, indeed, the correct understanding, and perhaps provide a situation where this would be genuinely useful?
Thanks.
Really, the use of Objective-C in OS-X is probably more about leveraging the NeXT codebase than any strong desire on Apple's part to reintroduce the language. Rather than try to struggle through morphing all the NeXTStep code to a different OO language and its less-elegant model, I'm sure it was easier for Apple to just hire a bunch of old NeXTStep/GNUStep coders, and port the whole package to the Mac.
Buying NeXT wasn't just a way for Apple to get Jobs back on baord; they really did (still do?) have some cutting-edge code, and it'll put them light-years ahead of where they would be if they tried to incrementially adapt the old Mac OS -- just look at how long it took MS to get rid of DOS, and imagine an equally daunting task being completed by the relatively tiny MacOS development crew.
Attributes aren't really the C# version of reflection; reflection lets you look at the normal things you'd expect it to, and it also lets you look for attributes.
Why should you care?
Well, attributes are really useful in cases where you want to pass some information about the class somewhere else but you don't want to make it part of the code.
With attributes, for example, you can specify how a class should be persisted to XML.
[XmlRoot("Order", Namespace="urn:acme.b2b-schema.v1")]
public class PurchaseOrder
{
[XmlElement("shipTo")] public Address ShipTo;
[XmlElement("billTo")] public Address BillTo;
[XmlElement("comment")] public string Comment;
[XmlElement("items")] public Item[] Items;
[XmlAttribute("date")] public DateTime OrderDate;
}
At runtime, the XML serializer looks for those attributes on the object it's trying to serialize, and uses them to control how it works.
You can also use attributes to communicate marshalling information, security information, etc.
The nice thing about attributes is that it's a common mechanism, and it's extensible, so you don't have to invent some new mechanism to do something similar.
Or, to look at it another way, attributes are just a general mechanism for getting information into the metadata.
That's why a compiler warning is entirely appropriate in either case above. It may be syntactically valid code, but it may not agree with the programmer's intuitions, so it's worth pointing out to possibly save the programmer time looking for the non-obvious. However, if the programmer meant to violate the indentation rules, or simply didn't care (for a quick-and-dirty program perhaps), generating different code based solely on indentation is an attempt to second-guess the programmer, and a really bad idea.
To give you an idea on a case where the programmer might deliberately violate the indentation, consider debugging code... I will usually put temporary debugging statements flush with the left edge when I'm planning to remove them immediately after tracking down a particular problem. Because it looks wrong, it stands out, which is exactly why I do it. And I don't want a compiler second-guessing me and generating incorrect code because the compiler doesn't agree with my use of indentation. Indentation is for human readibility, and humans are more complex than programs. Syntax rules like this are an unnecessary constraint on the programmer.
As for your second example, that sort of problem is why I always use braces on single-line blocks like that, in case another line is added later. (Hours wasted debugging someone else's code that moved key code out of a loop convinced me to change my personal coding standard, 10 years ago.) I'll drop the braces only if the statement starts on the same line with the "if", "while" or whatever. (Perl goes a step further and always requires braces; I consider this perfectly reasonable, and a much better solution than Python's.)Instead, Python opens you up to brand new potential surprises. Suppose you're trying to debug a program by reading through the code on a printout, and there's an indentation shift that happens to coincide with a page break? You might not notice the difference visually when moving from one page to the next, but the compiler may not do what you expect from looking at the printout, if there's a mistake in the indentation. Braces, at least, are visible and matchable.
Also, many programs take a cavalier attitude toward whitespace, especially leading and trailing whitespace. If you were to display a python program in HTML and not disable the normal HTML formatting, the entire program will be re-wrapped. This won't hurt a C or Perl program much, but it would cripple the meaning of a Python program. If you send a program through email, a mail system could strip leading whitespace (stranger things have been known to happen). A text editor might expand tabs to spaces, not necessarily at 8 spaces per tab.
Because whitespace typically has minimal significance, there's a lot of potential for it to get mangled in one way or another. That is one of the biggest dangers I see in Python's approach, and it just seems to be begging for trouble.On the contrary, you should want that kind of redundancy, because it improves your chances of catching errors, especially when the compiler help automate the validation of those redundancies. Consider C function prototypes. K&R didn't feel it was necessary to declare parameter types before calling a function. After all, that information is already there in the function call (types of expressions) and definition (types of parameters). Why bother repeating information you already have? Because it catches mistakes. ANSI C catches (at compile time) many mistakes that programmers make, which K&R C missed, because of stronger typing. This redundant semantic information is a good thing.
I stand by my opinion that Python's significant whitespace is an abomination. It second-guesses the programmer and invites trouble with whitespace-mangling. Dropping the braces removes the redundancy that could catch the problems that are likely to be caused by significant whitespace. (Had Python kept the usual braces, it would have mitigated most of the damage of making whitespace significant, and I would have much less objection to it.)
Yes, it's a good goal to want to improve code quality and reduce mistakes. Perl's solution is much cleaner, safer, and so unobtrusive that people barely notice it and nobody particularly minds it. Python's approach, on the other hand, was ill-conceived from the start.
Deven
"Simple things should be simple, and complex things should be possible." - Alan Kay
I've seen plenty of comments mentioning Java's shortcomings but none mentioning C++'s: name-mangling and the lack of an industry standard.
Case in point: I work for a company that deploys a large C++ application on 5 platforms: Solaris, AIX, HPUX, NT and Dynix. For part of the functionality we rely on licensed, commercial, dynamically linked C++ binaries. The vendor of those binaries builds them with the native compiler on each platform. However, our code is heavily templated and performance-dependent and can only be compiled with 1-2 compilers, Kai's being the only one that works on all platforms... since Kai uses a different name-mangling structure than each native compiler, we've had to write C wrappers for everything.
Now, it seems that an ECMA-compliant, standardized language (if C# becomes that) will fix a lot of this nonsense...
engineers never lie; we just approximate the truth.
C++ style genericity is unmatched in its expressiveness and efficiency for scientific computations. If you are going to have value classes (also called "expanded classes"), you need C++ style genericity with it to use them for anything useful; without that, they become nearly meaningless. An ML-style implementation doesn't even come close in providing the necessary functionality.
On the other hand, C++ style genericity is cumbersome and inefficient for general purpose "application programming". For that, the ML style implementation (and GenericJava) genericity is much better.
I hope the GenericJava folks are not working under the assumption that the ML strategy is always preferable, because if they do, what they produce will likely be useless for high performance applications. Compiler-created specializations of generic classes, including type variable specific overloading, and value classes are the backbone of high level, high performance computing.
Anytime you come up with a name where you have to explain the pronunciation every time you use it, you know that its a real lamer. Its a dead give-away that you worked too hard, stayed up too late, and got too cute.
Of course, there _are_ lots of ways to say C#. I always think 'hash' everytime I see '#', and if you use the hard sound for the letter C, you get K-hash, or simple Cash. Which I think fits, considering the orifice from which it issued.
Cheers!
"The only good windmill is a tilted windmill."
In 2000, Objective-C is still nice in many ways but it's dated. Java receives all the "hype" because it is at the sweet spot of backwards compatibility and new features right now. Most importantly, Java is runtime safe and it has well-defined reflection, something Objective-C always lacked, and something that is essential for a modern component market. I think Apple is making the right decision in going strongly after Java in MacOS X.
I think it's an unfortunate misconception that C is the ultimate "power language" because it gives you so much "control". There are lots of advanced languages around (Eiffel, Haskell, ML come to mind) which are more powerful than C precisely because of their restrictions. (You can reason about your programs more precisely since you know certain behavior is impossible). Java has some of this (safety, at least) and I think that makes it better for most applications than C++.
I'll agree with you here, though: aside from a few cosmetic improvements, C# is not really any better than Java.
Depends on your definition of correctness.
if( myCondition) {
doThingOne();
doThingTwo();
}
1) It would at least run. Can't say that for python.
2) Who writes code like that anyway?
3) By pressing exactly one key (actually a vulgar combination of three bucky bits and a key) in emacs, i can reformat the entire source so it is indented properly (this function does marvelously with C and C++ except for multiline macros, has some problems with perl). Since indent determines scope in python, this trick is impossible with python.
Maybe when I have less worries about being able to pay rent and grocery expenses in the near term (translation: i get a job) I'll resume my work on ni, which stands for "no indent", and will be my attempt at writing a new grammar for python that will still produce compatible bytecode. Just for kicks, I'll probably merge stackless in with ni as well, and will probably start diverging from the language once the grammar is established. I had the basics of the grammar working, but thanks to the coziness of python's lexer and parser, it still has some problems.
I've finally had it: until slashdot gets article moderation, I am not coming back.
Java has an enormous number of man-years poured into its design, library, bug fixes, and various implementations. Issues like safety, sandboxing, security, and reflection aren't even addressed by C#. A complete set of cross-platform libraries is also not a goal of C#, while Java actually delivers, and delivers pretty well. And people are working hard at adding genericity and features for high performance computing (JavaGrande) to Java.
If Windows programmers switch in droves from C++ to C# that would be great: as far as it's defined, C# is almost indistiguishable from Java, and it would elevate the quality of software on Windows platforms. But, at this point, C# looks like a dud to me: it's late, it's non-standard, has no user community, and it doesn't even promise to offer any compelling advantages over Java.
> Really elegant boxing would allow you to treat primitives as full, first class objects. Then you could, for instance, have a synchronized block use an integer as its lock object.
Bad form. First of all, nothing about an int says "lock", specialized lock classes like Mutex or Semaphore and whatnot are far more descriptive. Secondly, that lock probably requires a unique value now, where otherwise it could be reused by other unboxing operations using the same value. (i.e. one lock on a "5" object now requires a different object than a different lock on a "5" object)
Smalltalk has been doing automatic [un]boxing for eons now, I'm disappointed to see other languages still don't do this.
I've finally had it: until slashdot gets article moderation, I am not coming back.
Edit those routines at the spot! You can not survive in such an environment for long. So, for your own health, make certain you quit/get fired soon!
I have been working in an environment where there where no clear specs from the customer and where there where more or less no docs on the libs the customer wanted me to use. And I honestly don't want others to have the same nightmare (By the way, my coworkers where the best team you can ever get on this planet, so the job wasn't all that bad).
--The knowledge that you are an idiot, is what distinguishes you from one.
--The knowledge that you are an idiot, is what distinguishes you from one.
I think you are a bit confused about early/late binding. Early binding is the process of determining the address of the function to call (given it's name) at compile, link, or load time. This happens once, so it is fast. Late binding is the process of determining the address of the function to call each time it is called. In C++, late binding is used for virtual functions, and early binding for non-virtual functions.
There are optimizations that enable late-binding to be more efficient (such as a vtable). Java implementations should be able to determine (via the final attribute) that a function can be early-bound instead of late-bound. There are also C++ compilers that can eliminate virtual function calls by doing link-time program analysis.
-- Too lazy to get a lower UID.
You can also use attributes to embed documentation, contracts, etc. People who compile from a high-level language to C# (already happening) will no doubt have many uses for attributes. Attributes are more of a tool feature than a language feature -- as a programmer you probably won't use many of them, but if you are systems programmer you might use them (or generate them) a lot.
Generics are not the same as templates. There are literally hundreds of languages out there that don't use templates for generics. In the .NET
runtime it looks like the approach will be to use a sort of dynamic
template expansion technique (you expand the templates as you JIT --
although this is a gross simplification). There are several languages
that already have generics on the .NET platform -- Eiffel, Mercury,
Haskell, ML (although I think ML uses whole-program compilation to
eliminate real genericity).
Finally, AFAIK nothing in .NET relies on COM. There is certainly full COM
interoperability built into the system libraries and tools -- basically
there is a tool that takes a COM type library and turns it into a .NET
component by creating forwarding stubs. There is an interop library
that does marshalling and so on. But if your code doesn't rely on a COM
component, you don't need this stuff.
Of course as a platform at the moment, most of the interesting components you would want to use are COM components. But if people write 100% .NET code, you can run it anywhere. Obviously some people will not
do this -- it makes a lot more sense to just script COM components in .NET, at least until there are enough .NET components to replace them.
But given that deployment of .NET components is a lot more controlled
that COM, there is certainly some incentive to replace them.
Of course there are still platform specific APIs to contend with, but
they are always going to be an issue.
So AFAIK there's no reason why you couldn't write a .NET framework, and a C#
compiler that works under Linux (or whatever your favourite platform is).
This will be really quite possible if Microsoft does what they say they
will and standardizes them. You could also hook in support for CORBA
interoperability. You could put in support for SOAP. You could allow
it to run under Apache and do something like ASP+ and web methods.
I'm so lame that I am unable to learn a new programming language syntax. Even though it's been thirty years since computers have become powerful enough to support parsers that can figure out the end of a statement without an explicit delimiter, it makes me feel all warm and fuzzy inside when I put that semicolon at the end of every line. Even though named arguments might be preferable to sequences of anonymous types, a new messaging syntax would more than my fossilized brain can tolerate. Asking mere computer programmers to learn something new is asking a little too much, after all, programmers tend to be slow learning. Instead, we should perpetuate outdated and inconvenient syntax. We wouldn't want to frighten the poor wittle programmers with something as radical and hard to grasp as a different syntax.
*sarcasm*
Burris
Sorry, but I have too much real world proof to let this stand. PHBs really do exist. Not all managers are PHBs, but go to any reasonably sized company, and you'll find them...
"The invisible and the non-existent look very much alike." -- Delos B. McKown
I recently went to a brief presentation on C#, done by some Comp Sci folks just back from the MS developer conference.
A few points I recall:
Someone asked why we need another language, especially one so close to Java. The presenter(s) explained that MS basically wanted to offer a VM based Java-like language, but was unable to add their own extensions to Java fit in with their new strategy (remember the lawsuit from Sun?). They remarked that perhaps Sun made a mistake in their desire to keep MS from making non-standard alterations to the MS implementation of the Java VM. MS, as usual, just went ahead and created their own new standard. Now we have another language to pull developers away from Java.
my_int bar(my_int x) {
x+=1;
return x;
}
my_int foo() {
my_int y = 2;
bar(y);
return bar(y);
}
foo returns different results depending on whether or not my_int is a struct or a class. You cannot tell if modifying the object will modify the original or not without looking for the original class definition which can be buried pretty much anywhere in c#, because it has abandoned the rigid formalism that Java used of one public class per file and the name of the file matching the class.
Mind you, Microsoft will probably sell a nice Visual Studio plugin which looks up the source definition and shows you if its a class or struct, and which allows you to hyperlink to the definition (witness MSVC and VB), but I'm examining the language, not Microsoft's tools.
I disagree with the author of this article about the presence of Attributes. Attributes (as ugly as they are) create an avenue to extend the metainformation provided by the language. Since the attributes reside at the class rather than instance level, the glut of their presence is not intolerable. Their presence is necessary to fully specify COM parameters, they can act as a reflection tie to documentation, provide editor bindings to source code, etc.. in one place, rather than java's comparatively hackish javadoc approach of differentiating /* and /**. Its new, its different, but I can accept it and already see uses for it.
However, I do not see the need for Events to be a language level construct. With the introduction of generics/templates they could be implemented as a generator/listener template with a common superclass and subscribers tracked in a static list per event template used. No extra nomenclature need be added to the language to describe what is just another pattern afterall. In the absence of generics I suppose they did the best they could, but its another case of pandering to their present programming paradigm (pardon the alliteration).
I do miss the presence of java's inner classes and either c++'s templates or some other form of constrained generics (can anyone say Eiffel?).
In fact the lack of any form of generic will probably keep me from using the language as I am a pattern junky, and templates/generics are key to avoiding a lot of cut&paste code when using similar patterns heavily.
Sanity is a sandbox. I prefer the swings.
Despite the success of C#, programmers began to complained that though C# provides much of the functionality of Java with the flexibility of C++, there exists a middle ground between C++ and C#.
C#++ is desiged to fill that middle ground.
CaptChalupa, a MicroSlash programmer, said, "I love C++, and always programmed in C++. But the lure of the C#, which my colleagues have raved all over, is tugging me. The reason I don't want to abandon C++ is because I still like to keep the flexibility of collecting my own garbage. C#++ is the answer that may just finally pull me away from C++."
Meanwhile, in another development, Microsoft Applications Inc. has announced the development of a new language called "C##".....
Mode (3) smart-aleck mode. Press * to return to main menu.
Since the first day I heard about this language, I have been excited about it. The more that I read about it, the more I can't wait to see that pretty little brown MSDN box come in the mail with my copy of Vis Studio 7.
0 /08aug00/bn0008/bn0008-1.asp
As a Microsoft-whore, the ability to develop with the new tools of VS7 (which, BTW, features C#, VC++, Managed VC++, and VB all running in the same IDE with concurrent, multilanguage debugging... baby!) has taken over. I am working on a project that requires two WinCE portions and a data management system. The things I've read have made me make the conscious decision to do no code development on the data management portion until VS7 is in my hand and on my machine.
This month's Visual C++ Developers Journal has a cover to cover exposé on VS7. This is a link to the online article.
http://www.devx.com/upload/free/features/vcdj/200
"Blue Elf has destroyed the food!"
Because you can't, you won't, and you don't stop...
I shudder when I think of programming with significant whitespace. It's what has kept me from picking up Python in earnest--at least until I write a conversion program that turns braces into the whitespace that python likes (in Perl :-).
To think that C would be made *better* by the addition of significant whitespace gives me the chills.
Agreed! I've been told a number of times that Python is a good language, but that one design flaw (making whitespace significant) has kept me from wanting to touch it. It would be okay for the compiler to generate a warning for incorrectly-indented code, but to generate incorrect code instead is simply inexcusable. Grafting this abomination onto C is a disturbing prospect indeed.
Deven
"Simple things should be simple, and complex things should be possible." - Alan Kay
Does this mean that C# will be as much of a moving target as C++ was for the first 10 years of its existence?
(I don't mean to sound surprised, as this is a Microsoft language, which needs continuous "innovation" to maintain market-share.)
To me, one of the huge reasons not to use C++ was that, even though I had learned an earlier version years ago, when I came back a few years later, Bjarne had added a few new features that were now "essential" to implement some "crucial" paradigm. E.g., suddenly templates are crucial to programming in the true C++ religion. Never mind that compilers took years to get them properly and consistently implemented, while hackers seemed to keep pushing templates harder and harder for compile-time code generation, in ways that were bound to activate any subtle, lurking bugs in a compiler. Same with exceptions, RTTI, et al.
My main gripe is that it is hard enough to deal with languages where people keep coming up with half-solutions to new problems by changing the language definition. How much worse will it be when Microsoft, with its commercial interests, gets in the game?
Microsoft played up the fact that their approach to boxing/unboxing would be fairly innovative in C#, and this got me pretty psyched. Basically, boxing is a way to convert primitive objects (ints, etc.) to instances of the generic C# 'object' class. That way, you can treat primitives like objects, but without the performance loss in cases where you just want them to be plain old primitives (I imagine something similar happens with structs?).
Sadly, I took a skim through the "Introducing C#" book, and noticed that boxed primitives are completely distinct objects from their unboxed versions. So, if I do "int x = 10; Object xobj = x;", the new xobj is completely unrelated to x from now on. I can later do "(int)xobj += 100; print(x)", and x will still be 10.
In other words, this is (as far as I can tell, please correct me otherwise!) exactly identical to doing "xobj = new Integer(x);" in Java, just 'syntactic sugar' as they say. You could add this pretty trivially to Java with few little tweaks to the front-end (and maybe somebody should).
Really elegant boxing would allow you to treat primitives as full, first class objects. Then you could, for instance, have a synchronized block use an integer as its lock object. Or you could store an integer in a collection (say, a hashtable) and have the hashtable entry properly updated as the original int is changed (as if it were any other mutable object). These aren't huge deals in the grand world of language design, but their efficient implementation would actually be kind of interesting.
--JRZ
I've been thinking about this one for a couple of days and all actually fits in. Assume the following events:
C# will be ignored by SUN/IBM etc. for the next 2-3 years since they heavily back Java and are reluctant to invest in competing technologies.
While being ignored by their competitors Microsoft does some heavy promoting of C# to windows developers and succeeds into making it the primary windows development environment. Ofcourse using Visual Studio. (I think this will be easy due to the current gap between Visual Basic, which is too simplistic to do any serious component development in, and Visual C++, too hard, ever used ATL? C# fills the gap nicely where Java fills the same gap on other platforms.)
Higher level Windows API's are wrapped in C#-accessible classes or components and a lot of the code implementing this is ported to C#/IL. Using the same strategy as with Windows, there are 2 APIs: one public and one internal.
C# is accepted by ECMA into the standarization process. The language and associated libraries are standarized. The standard process progresses fast backed by Microsoft and it's partners. Except for Microsoft itself, no-one tries to keep up.
Microsoft looses its appeal is split up into an OS and an Apps company. The Apps company keeps Visual Studio.
The IL and libraries (.NET framework?) are ported to a different operating system (e.g. Linux) and most code that would run only on windows now runs on that other platform with minimal effort. Ofcourse only when the Microsoft implemented libraries are installed and paid for.
Effect: Microsoft Apps company doesn't need the Windows OS anymore and controls the API used in most commercial applications on several platforms and also has a secret internal API that they can use for pushing too powerfull players out of the market.
Thoughts?
Even if speed is a big issue, you can still used Java. The least platform-independant stuff to program is the user-interface. This is were Java shines, I think. I don't care how slowly it runs, Java can keep up with my mouse clicks!
For serious number-crunching, using JNI to hook into some optimised native libraries, which can be built with a minimum of platform-dependant code if you don't count Makefiles, all-but-negates any speed loss that going with a purely Java solution would give you.
My understanding is that C# can also call libraries like this, and that it's way easier for other languages to call C# methods than Java methods. But with it's heavy dependance on COM, I'm not sure how widespread C# could be outside of the Win32 system. Does it even provide it's own windowing toolkit, or does it jack into the exiisting OS calls?
Love, Spud.
You can never put too much water in a nuclear reactor.
Just asking.
The one argument for C#, and against Java, seems to be performance. If C# delivers better performance than Java, than C# will be better. I'd argue that, but I left my asbestos undies at home.
Well... Where are the Java bytecode-to-native compilers to make this a non-issue?
Seems to me that improving the performance of an existing language (albeit at the cost of platform independence, obviously) would be much simpler than developing a whole new language to include the piece that Java is missing - a native compiler.
-- What you do today will cost you a day of your life.
speaking of compilers, wouldn't it be funny if Sun released a compiler for C# that didn't follow the language specifications exactly as Micrsoft has detailed them?
I wonder who would win that court battle...
I shudder when I think of programming with significant whitespace. It's what has kept me from picking up Python in earnest--at least until I write a conversion program that turns braces into the whitespace that python likes (in Perl :-).
To think that C would be made *better* by the addition of significant whitespace gives me the chills.
SteveIt would be okay for the compiler to generate a warning for incorrectly-indented code, but to generate incorrect code instead is simply inexcusable.
Depends on your definition of correctness. ;) If you wrote:
On a quick visual inspection of the code, I'd assume that doThingTwo() was outside of the if clause, and if you wrote:
I'd definately assume doThingTwo() was inside the if until I looked closer to notice the braces were missing. In this case, the "correct" code would be very suprising.
In python, you don't have these sorts of suprises, your block structure is immediately obvious from indentation, and if it looks wrong, it is wrong. I'd call that correct code generation...
I'll admit I was a little put off by this feature of python at first, but as soon as I started working with it for awhile, it just seemed natural. Now in my Java programming I always get annoyed when I have to spend time balancing my braces!
Also, I used to do alot of work in perl with a guy who never bothered to indent his code consistently (after all, its the braces that define the block structure) and at least once a week, he would call me over to look at some bug that became obvious as soon as I reformatted the code. And applying the pragmatic programming principle of DRY (Don't Repeat Yourself), what is the point of having the same semantic information encoded in the formatting (where it is visible to the programmer) and brace structure (where it is visible to the compiler). If you've got the same information in two places, eventually they'll get out of sync, and you'll lose...
White space schmight place.
Python is truly a wonderful prototyping language, but as soon as any project I use it for (tend to be home-sys admin things) I always get bitten by the global/local scoping rules (*).
I would cry tears of happiness if it only had lexical scoping. My "I'll just fix it" threshold is pretty high, but I've just about to reached it.
Johan
(*) variables in methods are global if you only read from them in the body, but if you assign to them in the body, they become global. Scoping is dynamicish, allowing you to declare the global afterr you have declared it in the method, as long as it occurs first in the runtime. The semantics are way to ad-hoc, no?
they become global
local.
preview, what's that?
A lot of people seem to be under the impression that C# is only available to those who went to the PDC. Nope. For a couple days, it's been available at Microsoft's site, and according to them, it's the same "sample bits" distributed at PDC.
Get it here. It does require Windows 2000 though.
Working toward a usable PDA environment in the spirit of Newton OS: Dynapad
Perhaps the more fatal flaw is that you refuse to touch it because of that attribute (significant whitespace).
Actually, I've heard enough good things about the design of the language as a whole that I've decided I should overlook the whitespace thing and learn it sometime anyhow. However, it took a lot of praise from other sources to convince me that it might have sufficient redeeming qualities to outweigh this abomination.
Try it out for a while before you write it off as a design flaw.
Whether or not it's a technical design flaw, which is debatable, I'd suggest it's a social design flaw if it makes many programmers reluctant to seriously consider using the language (which it does). Some programmers may like it, others may manage to set aside their distaste for it, but many simply won't touch it at all. That's a flaw, if it makes an otherwise-good language worthless because it gets rejected out of hand.
Deven
"Simple things should be simple, and complex things should be possible." - Alan Kay
No-one knows the future; C# may succeed on the Windows platforms and be a vital line on your resume, or it may flop totally and be rejected by developers, and M$ may drop it in 2 years.
As for C and C++, I find it amusing that the one part of C which you like (pointers) is the one aspect which has taken the most criticism over the past few decades!
You don't really explain why you dislike C/C++ - apart from having someone "watching your back". Well, the solution is to learn to write robust code. Run-time errors are useful, but if you're shipping software it shouldn't have any, so run-time error checking is a waste of the end-user's time.
I mean, I could understand it if you hated the C syntax, or C pointers, or C++ backasswards compatibility with C, or the appalling non-portability of C. But if you dislike C because it reveals your subtle bugs to you, then you should really learn how to write bug-free code. It's a much better thing to have on your resume than knowing ANY specific language. And C/C++ are going to be around for a while.
--
It's a
-- Danny Vermin
Amen, brother! I have yet to fathom why anyone would want to use the hard-to-type curly braces for block notation where you can just use an "end" keyword at the end of blocks instead. An if-then-else-end construct saves 3 keystrokes (7 if using implict "THEN"s) over a readably-formatted if () {} else {}. Not to mention that typing the curly braces is more difficult and error-prone than typing "THEN", "ELSE", or "END." (Note: I'm including shift keys as keystrokes for the calculation.)
Now, one might say that 3 keystrokes are no big deal, but when this kind of construct is the most common in the hand-coded parts of a program, it adds up (your fingers notice the difference).
When I first read about C#, I thought "Great! A new language with new ideas!" But, upon reading the specs, it's the same old C-syntax garbage we've been fed for years. I'm surprised there hasn't been a good cross-platform compiled language yet that does away with the dreaded curly braces.
I, for one, would welcome it.