C, Objective-C, C++... D! Future Or failure?

TDRighteo writes "OSNews is carrying a quick introduction to a programming language under development - D. Features include garbage collection, overrideable operators, full C compatibility, native compilation, inline assembler, and in-built support for unit testing and "Design by Contract". With all the discussion about the future of GNOME with Java/Mono, does D offer hope of a middle-road? Check out the comparison sheet."

Comments

wow

[spangineer]

Who said computer geeks don't have any creativity in naming their programming languages?

Oh, wait...

Re:wow

[slickepott]

I think they still had some good choices with the C.. I have loads of cool signs on my number keys to play around with. *C, //C, &C, "C", /*C*/, C--, C+=1 Why the rush for D already?

Re:wow

[91degrees]

I'd like them to come up with a better name. D makes it very hard to find information about it on the web. A name like "zlxrt" would be better since it would get zero hits that weren't about the language.

For the pedantic - I consider this post to be about the zlxrt language.

Re:wow

[rishistar]

You guys are all behind the times. I'm already on E!

Yeah - turn up that thumping music man!!!

Re:wow

[twocents]

Yes yes yes.

Look for .Net in Google - the first result is php.net. That should offer a lesson for anyone.

Re:wow

[squiggleslash]

Kind of sad really. If the inventors of this language had any sense of history they'd have called it "P" (Remember: there was no language called A, Ken Thompson's naming convention wasn't alphabetic, it was after BCPL, the language he was trying to improve upon.)

Re:wow

[llimllib]

D's only link-compatible with vanilla C, so you'd need to create a GTKD wrapper, or just use regular old gtk.

Re:wow

[gunpowder]

No, I think he meant this.

Re:wow

[Jorkapp]

Wikipedia: B Programming Language

It was essentially BCPL stripped of anything Thompson felt he could do without, in order to fit it on very small computers, and with some changes to suit Thomson's tastes (mostly along the lines of reducing the number of non-whitespace characters in a typical program).
...
According to Ken, B was greatly influenced by BCPL, but the name B had nothing to do with BCPL. B was in fact a revision of an earlier language, bon, named after Ken Thompson's wife, Bonnie.

Microsoft will come out with it's own version

[eclectus]

Microsoft will come out with it own version, and call it D-.

Re:Microsoft will come out with it's own version

[b4rtm4n]

Visual D

Cue loads of VD jokes :-D

Re:Microsoft will come out with it's own version

[stevesliva]

I was thinking Double-D.

Re:Microsoft will come out with it's own version

[Lord_Slepnir]

Heck, I got enough of a kick out of Visual C (VC). Made me want to listen to acid rock and hunt Charlie.

Re:Microsoft will come out with it's own version

[Anonymous Coward]

You know why you can't get information on Visual C on the web? 'Cos Charlie don't surf.

Re:Microsoft will come out with it's own version

[T-Kir]

Or instead of sharp, use the hash orientation and you could have D-bong... mind you'd have to be on drugs to be able to use it though ;-)

full C compatability?

[beegle]

I think the "full C compatability" is a problem. It's -not- a feature.

In "small program" languages like perl, giving people lots of ways to do things is a feature. In a "large program" language, providing both C compatability and garbage collection is a maintainability nightmare. You'll have people who use both, or worse yet, who only understand one, so to understand the mixed code that results from a hybrid langage like this, you'll have to be utterly proficient with -both- languages.

Re:full C compatability?

[Anonymous Coward]

I don't know, I think objective-c handled it pretty well and clearly. It's a superset of c, and it's optional garbage collection is as simple as setting or not setting the auto-release flag when you construct your object.

I wish the article actually compared to objective-c, as the story's poster seemed to imply...

Re:full C compatability?

[Elbows]

Actually, the post was a bit misleading -- D only provides *link* compatibility with C. You can link to C libraries without any trouble, but you can't compile C source code in the D compiler.

Re:full C compatability?

[PhrostyMcByte]

Agreed. Though it's generally bad practice for libraries to allocate their own memory for returned data, it happens.

Because it's not handled by D's garbage collection, it still needs to be freed. I'm sure this will make those developers who love to leak memory even worse.

Re:full C compatability?

[noselasd]

No. Its a very nice feature.
Just about anything you need, there's a C library for it.
Think nice things like opengl,pam,openssl,GUI librairies, database
libraries, and heaps more.
Having access to those is very nice, and you don't have to wait anyone
to port those to a new language(which probably won't happen anyway.)
I'd imagine how far C++ had gotten if it couldn't use C libraries..

Re:full C compatability?

[orthogonal]

In a "large program" language, providing both C compatibility and garbage collection is a maintainability nightmare.

For those of us who don't like unpredictable...

pauses...

in our programs while the garbage collector does its work, will we be able to turn off garbage collection entirely or run the garbage collector only at specified times?

I'll answer my own question: even if this is possible, if D ever becomes a serious language, we will be using libraries written by other people, libraries that do rely on garbage collection.

So, no, we won't (realistically) be able to turn off the garbage collector, which means that we won't be able to write real-time programs, and it'll even be touchy writing programs, such as, oh, audio or video players, that require near real-time performance. (Not to mention the disappointment we all felt with the various java window-widget APIs (AWT, Swing) that looked great but couldn't run fast enough to respond to the mouse.)

Look folks, taking care of your own garbage wasn't possible in C for a library writer (even ones returning opaque pointers to structs that allocated their own memory) because you had to rely on the library user to call your cleanup function(s).

But the library user could clean-up. The problem was essentially that some programs didn't care enough to be careful -- pointers actually had to be tracked.

Now, it's fine if a library user wants to add on a garbage collector by re-writing malloc to track allocations. But libraries, which are intended to be used by lots of programmers, to write code, and by lots and lots of end users who run code should not use garbage collectors themselves -- because that forces the library user to use garbage collection too.

But in C++, library writers can write libraries that take care of their own garbage even when used by careless users, because the compiler will automatically call class destructors which can do clean-up. (Yes, except in the case of derived classes -- the writer of the derived class has to explicitly write a dtor to ensure the parent class dtor is called.)

And in C++, with the Standard Template Library, there's little need for non-library writers to do explicit allocation at all -- std::vector and std::string and std::auto_ptr, just by themselves, take care of most of the problems of memory leaks and buffer overruns.

If you're using C++ and you feel that you're a good enough programmer that there's real need for you to be calling

new

directly, them you're a good enough programmer to ensure that you've called

delete

for each new. And with std::auto_ptr, it's as easy as

std::auto_ptr<foo> pfoo( new foo ) ;
pfoo->do_Stuff() ;
return ;
// auto_ptr calls delete on pfoo, right here,
// without you doing anything,
// and without garbage collection overhead

How much simpler does it need to be?

So why complicate things with garbage collector and tracking down circular references and unpredictable pauses? Garbage collection is a bad answer for non-trivial programs, and pretty much necessary for trivial programs.

Re:full C compatability?

[Mr. Piddle]

Though it's generally bad practice for libraries to allocate their own memory for returned data, it happens.

It happens a lot. I've seen a few expensive C-based libraries that clearly show their designers struggled with the classic caller-callee allocation dillema and lost. Debugging memory leaks in programs that use these libraries is typically hopeless and requires high effort-versus-progress computationally-expensive run-time checks to find them. I like C quite a bit, but it is disheartening to see such a simple malloc() function cause so much pain.

Re:full C compatability?

[Haeleth]

we won't (realistically) be able to turn off the garbage collector, which means that we won't be able to write real-time programs, and it'll even be touchy writing programs, such as, oh, audio or video players, that require near real-time performance. (Not to mention the disappointment we all felt with the various java window-widget APIs (AWT, Swing) that looked great but couldn't run fast enough to respond to the mouse.)

Yeah, nice FUD. Java is slow because it's bytecode, not because it's garbage collected. (Incidentally, all the Swing applications I've used recently have been every bit as responsive as I could desire, so it isn't even necessarily slow.)

So why complicate things with garbage collector and tracking down circular references...

BOOM! And you reveal that you don't know what you're talking about. Circular references are irrelevant to any GC scheme more sophisticated than reference counting. They simply have nothing to do with it.

I suggest you read this. Pay particular attention to the bits that explain things like "Modern garbage collectors appear to run as quickly as manual storage allocators (malloc/free or new/delete)," and "for very many applications modern garbage collectors provide pause times that are completely compatible with human interaction. Pause times below 1/10th of a second are often the case," and "Does garbage collection cause my program's execution to pause? Not necessarily.".

Then come back and make some informed comments, instead of spouting nonsense. Thank you.

Re:full C compatability?

[WWE-TicK]

> Yes, except in the case of derived classes -- the
> writer of the derived class has to explicitly
> write a dtor to ensure the parent class dtor is
> called.

This is wrong. If your compiler requires this, then your compiler is broken.

The destructor in a base class has to be made virtual though to ensure that correct destructors will be called if you do something like this:

Base* o = new Derived();
delete o;

where Base is some class and Derived is derived from Base. If Base::~Base() is not virtual, then Derived::~Derived() would never get called.

Re:full C compatability?

[Darren Winsper]

Err...he said real-time applications. Because the behaviour of a garbage collector is often approaching non-deterministic (You don't know when it will run or how long for), it's not acceptable for real-time systems. Real-Time Java gets around this by having other memory models which don't involve using the heap, along with providing types of threads that can run in parallel with the garbage collector.

Re:full C compatability?

[orthogonal]

BOOM! And you reveal that you don't know what you're talking about. Circular references are irrelevant to any GC scheme more sophisticated than reference counting.

My point was that to avoid the problem of circular references, the garbage collector does have to be more sophisticated, and sophistication takes time and (memory) space -- time and space that a program may or may not be able to spare.

"for very many applications modern garbage collectors provide pause times that are completely compatible with human interaction. Pause times below 1/10th of a second are often the case,"

Pause times below 1/10th of a second? Hmm, how much below? TV-quality video is 24 frames per second, so a one-tenth second pause means dropping two or three frames. Acceptable? Perhaps, but not desirable.

"Does garbage collection cause my program's execution to pause? Not necessarily."

Yes, if you read my post carefully -- perhaps you missed a word or two when the garbage collector in your head did some clean-up -- I didn't say that pauses were inevitable. My complaint -- and not just mine, it's no revelation that garbage collection has may detractors -- is that the pauses are not predictable by writer of the program.

With non-garbage collected language, I know that memory allocation will either succeed ort fail, and I know (or a library writer knew) when allocation happens, because I'm explicitly coding it. So I know, at this particular point in my program, either allocation succeeded or failed.

But garbage collection can happen at any time, and cause a pause at any point in my program -- even when I'm needing to re-fill under-run buffers or read volatile memory or make time-critical choices. With garbage collection, I no longer have an algorithmic program, in which I can say what it's doing at any particular point in the code.

Then come back and make some informed comments, instead of spouting nonsense. Thank you.

That overly hostile arrogance suggests you're either a zealot or a fourteen year-old. That sort of blustering generally indicates someone who isn't that confident in himself or his argument, and so wishes to preempt questioning by being a posturing like a "tough guy"; it's particularly prevalent on the net -- though I'll grant that you didn't hide behind an Anonymous Coward post. Adults can disagree and discuss things without resorting to insults and attitude -- and I think you'll be able to do that too, with a little more experience.

Re:full C compatability?

[rblum]

Yes, he said real time. Big deal. If he actually was informed about the topic, he'd know there are several GCs that are useable for *hard* realtime. They have *guaranteed* response times.

Sorry - the whole "GC is slow" is a myth, unless you implement a naive GC. But guess what - naive memory allocation by hand can kill performance, too. (It's not like malloc is a speed demon, after all...)

Re:full C compatability?

[at2000]

No! It is call-compatible only.

D programs can import and link against C code and libraries, providing D with free access to a huge amount of pre-written code. Note, however, that D is not link-compatible with C++, so pure C wrappers are required to access C++ code in D.

Re:full C compatability?

[be-fan]

Malloc is still ridiculously expensive compared compared to what a generational GC can do. A malloc is dozens to hundreds of instructions, while in many cases (eg: when you're following the typical functional-language allocation patterns), a generational GC can alloc in just a few instructions. And while the GC phase itself is hardly speedy, the amortized cost of the GC is much lower than the non-amortized cost of doing all those free()'s individually.

Re:full C compatability?

[be-fan]

My point was that to avoid the problem of circular references, the garbage collector does have to be more sophisticated
No it doesn't. Handling of circuler references falls naturally out of most GC algorithms. One of the simplest possible memory algorithms is the mark & compact GC, which handles circuler references naturally.

Pause times below 1/10th of a second? Hmm, how much below? TV-quality video is 24 frames per second, so a one-tenth second pause means dropping two or three frames.
You disable the GC in those cases. A good GC will give you the option to manually manage memory in certain cases (say, through a pool allocator), so in any time-sensitive paths, you can disable the GC and rely on those other options. There are also real-time GC's that have absolutely bounded pause times.

But garbage collection can happen at any time, and cause a pause at any point in my program -- even when I'm needing to re-fill under-run buffers or read volatile memory or make time-critical choices.
You do realize that you have this issue with any modern OS? A malloc() can take tens of thousands of clock-cycles if it decides to mmap() to get more backing memory, and the kernel decides to block the app.

Re:full C compatability?

[iabervon]

An afternoon with Valgrind should track down most of these without too much effort. It's really gotten to be a nice "please tell me what's wrong with my program" tool, capable of letting you send in bug reports like "function X leaks a 20-byte chunk of memory and a 4-byte chunk every time I call it with these arguments." For now you can't determine things like "bytes 16-19 of the leaked chunk are a pointer to a filename", but I suspect that will be in a later version (determined by what system calls are called with it).

One thing I'd really like to see in Java is Object.free(), which would tell the garbage collector that the object is garbage and can be freed, and cause any further use of the object to throw a FreedMemoryException. This would be useful both as a hint to the system (letting it get rid of things the object references early) and as a debugging aid (so you can find cases where stuff remains in use after you don't think it will). Of course, it violates Java's sandbox design to have a C-style free() which recycles the address space.

Re:full C compatability?

[void*]

(From which many sensible people conclude that it's bad practice to write in C.)

Your 'many sensible people' would be ignoring that 'libraries allocate their own memory' and 'libraries that have fixed size return data' are not the only options.

Sure, you can do bad things in C. You can do "bad things" in pretty much any language - I just ran into an issue where a third party java library closed a stream I passed to it. It didn't create the stream, why should it assume I want it closed? It's a bogus design decision that limits the libraries usefulness - if I want a chunk of data processed by that library wrapped by other data that I write before and after the processing, I can't just write the data that goes first, pass my output stream to this lib, and then pass the data that I want after, I have to write the middle data out to a file somewhere and then reread and rewrite it. Should I now conclude that it's 'bad practice to write in java' because a third party came up with a poopy implementation of a util library?

I recognize that C allows worse things (buffer overflows, etc) to happen when such design errors are made. However, I think that anyone writing code in C should be aware of that - the code doesn't write itself, and the root of the problem is a given programmer following bad practices. You may blame the language for allowing it, but you can't blame the language for the presence of the given overflow ... the language spec didn't write the code. With power should come responsibility.

Re:full C compatability?

[mystran]

My point was that to avoid the problem of circular references, the garbage collector does have to be more sophisticated, and sophistication takes time and (memory) space -- time and space that a program may or may not be able to spare.

Then again, malloc needs sophistication as well, and can be every bit as slow as a good garbage collector. Indeed, even garbage collectors for C (try google with "garbage collector") can outperform the regular glibc malloc sometimes, even when there is NO reference counting involved. Which btw is another issue, reference counting + malloc pretty much combining the bad (and slow) things from both worlds.

Pause times below 1/10th of a second? Hmm, how much below? TV-quality video is 24 frames per second, so a one-tenth second pause means dropping two or three frames. Acceptable? Perhaps, but not desirable.

Such pausetime on a machine capable of playing TV-quality video in the first place indicate an awful garbage-collector. Even a stop-and-copy shouldn't take that much time, and these days we have generational collectors which only bother with the "youngest" stuff, that is, stuff most likely garbage. And you can make that incremental, it's not even very hard, and you can then slice the "pause" into almost as small parts as you want. There are collectors which provide real-time guarantees. Mallocs usually don't.

With non-garbage collected language, I know that memory allocation will either succeed ort fail, and I know (or a library writer knew) when allocation happens, because I'm explicitly coding it. So I know, at this particular point in my program, either allocation succeeded or failed.

Except this isn't necessarily true either. One example is Linux, which doesn't guarantee that there is memory left, because memory isn't allocated when you map pages, but when you touch them first time. If you allocate memory, and there's not enough free virtual memory to fill in the pages when you actually need them first time, then OOMkiller is called. Speaking of which, unless you lock (all) pages into memory, you won't know whether there'll be pauses anyway, since that memory of yours might just as well be a block of hard-drive space. Welcome to the world of virtual memory. Guess already which pause takes longer, a call to an incremental collector or the swap-in? Oh, and do you have a deterministic thread scheduler in your OS?

Finally, if you have an incremental collector (designed for this) you could run it with priority lower than your "real-time" tasks, and you could then collect only when the processor would be idle otherwise. Dijkstra's classical tri-coloring was actually developed for a scenario where there is one processor for running the task (mutator) and another for collecting the heap (collector). That you didn't think of this pretty much proves you've got no idea about garbage collectors.

Just because there are bad collectors doesn't mean they all are bad. And even stock solutions, over are the days when Lisp machines hanged for hours to collect their memory. Unless you are running the CPU at 100% all the time, you'll have plenty of time to collect.

Old news

[AKAImBatman]

1. D is not new. If this D is new, then we've got about 50 of them floating around by now.

2. Java and .Net are successful because they protect the program from complete failure. (i.e. error recovery ability) Making a C compatible language isn't going to help anything.

3. If a new popular language does come on the scene, you won't notice it until it has nearly taken over the world. Oh, and developers will love it so much they'll drop everything else (like what happened with Java).

Re:Old news

[fforw]

the java jvm can lock up hard. makes recovery quite interesting.

Off course it can lock up (nothing is perfect) , but it never occured to me. I experienced a few thread deadlocks, which are also not nice to debug, but only had one complete java VM crash - and that was due to faulty memory as memtest86 revealed.

also java and .net are "successfull" b/c of general investment from big companes. there's lots of marketing dollars selling products and articles about these platforms. the PHB's read the PHB magazines, and those mags have articles re java and .net. Do those mags have articles on D? then it's not a competition.

Sure there's a lot of hype around java related issues, but that isn't the reason for it's success. ( Every commercial software is hyped, dummies fall for hype - news at 11)

Java is successfull because:

• it offers a nice abstraction for system specific issues which is only seldomly leaky.
• you can dive into an unknown project, select a random source file and understand it. You may have problems getting the big picture, but the code itself is there - there are no suprises like operator overloading, defines etc. All you need to know about the class is in it (and it's superclass and interfaces)
• its complex enough to do some magic in it, but the idiot next cubicle can't run totally amok and wreck the whole system.

IMHO all these reasons are more important than for Java's success than hype.

Obligatory java response...

[mogrinz]

Looking at that comparison table, it's clear the author hasn't looked at Java since 1.4

Re:Obligatory java response...

[Nasarius]

I'm as excited about the new syntactic sugar in 1.5 as the next guy, but it *is* still in beta, and therefore not quite part of the "official" language. I for one can't and won't use the new features until there's a stable 1.5 JDK.

Re:Obligatory java response...

[wideBlueSkies]

I'm sure the gentleman will update his table once 1.5 comes out.

Templates.... great. It's like C++, but it's not.

Sounds like a good idea

[CharAznable]

I like this. It was about time someone saw the need of a cleaner, more modern version of C/C++ that takes the best features of the modern languages that are supplanting it in higher-level application development, like Java and Perl.
However, I it is doubful it will gain a foothold in the current ocean of multiple, semi-specialized languages.

D @ Google

[Jugalator]

Don't miss Google Directory if you're looking for more D info:
Computers > Programming > Languages > D

New programming languages are interesting, and sometimes I wonder what the next "big thing" will be. Will we have another big, revolutionizing, new concept like "object-oriented programming" that you simply must know in a near future?

try, catch, finally

[91degrees]

Wjhy do programming languages keep implementing this nasty tired interface? It's too bulky and long winded. Whereas I might just call a cleanup method if the function returns NULL, I'm actually obliged to deal with a thrown exception.

In theory this would be an ideal solution. It forces programmers to think about what they're doing. In practice, it doesn't. Coders are too busy thinking about the actual problem. Error checking gets in the way. They end up implementing the quickest way of ignoring the problem. The result is that we're no better off than if we just checked return values. The application should be doing what the user wants. Not the other way round.

Re:try, catch, finally

[PotPieMan]

As you say, programmers don't want to spend time worrying about error checking. The problem with return values is that some functions return -1, some return NULL, and others return some magic number depending on the problem. You can come up with rules and standards, but these are often broken or forgotten while programming.

Exceptions provide an obvious answer to the problem of how to handle different types of problems. If a file doesn't exist and someone tries to open it, a FileNotFoundException is thrown. If a file exists but the permissions don't allow access, an IOException is thrown.

Exceptions also provide a MUCH cleaner way of propagating errors. If one method calls another method to open a file, and the file can't be opened, how do you tell the original caller that there was a problem? With exceptions, you simply declare that your method throws IOException, and then (typically) skip the try-catch-finally block.

Summary

[TheJavaGuy]

D drops archaic C++ features like the preprocessor and forward declarations. It adds modern features like design by contract, unit testing, true modules, automatic memory management, first class arrays, closures, and a reengineered template syntax. D retains C++'s ability to do low level coding, and adds to it with support for an integrated inline assembler. C++ multiple inheritance is replaced by single inheritance with interfaces. D's declaration, statement and expression syntax closely matches C++.

Looking forward to job ads

[swapsn]

Looking forward to job ads saying :

• 10+ years of C#,Java programming experience
• 10+ years Windows 2000 experience
• 10+ years programming experience in D

Duh !!

D already exists?

[Anonymous Coward]

I remember reading something in a C book years ago about the existence of the language D, which was supposed to be an evolution of the C language, the book even specified some of the added benefits of D, this was before DigitalMars even started on D. I also know of a language called "E" on the Amiga, which was a C++ derivate and was explicitely not called D because D already existed, and I'm _not_ talking of DigitalMars' flavor. In fact I once mailed this to DigitalMars but never got a reply.
Can anybody confirm this in any way?

p.s. If I'm not mistaken there's also an "F", based on Fortran if I'm not mistaken.

Unneeded history

[xoran99]

From the article:

D is designed to address the shortcomings of C++. While a powerful language, years of history and unneeded complexity has bogged down that language. They want to overcome C++'s "history" while still maintaining C compatibility. Suddenly, I'm confused.

A, B, C, D, ... R!

[KjetilK]

Bah, We've allready made it all the way to R!

What about C++0x?

[Jezral]

What happened to C++0x?

Last I heard about that was in this Slashdot story from 2001...exactly 3 years ago, nearly to date.

But that was supposed to be the next official holy grail, no?

C!

[zegebbers]

We want C!
with apologies to eminem...
to the tune of 'without me'

Two GUI classes go on the inside; on the inside, on the inside
Two GUI classes go on the inside; on the inside, on the inside
Guess who's back Back again C is back Tell a friend
Guess who's back, guess who's back, guess who's back, guess who's back
guess who's back, guess who's back, guess who's back..

Sun's created a monster, cause nobody wants to code Java no more
or basic, but something quicker
Well if you want speed, this is what I'll give ya
A language called C that won't let you do "is a"
Some "has a" that makes me feel sicker
than the bugs when I build patch that's critical
using make to compile and be building
with a language that allows object orientating

Your var name's too long, now stop line breaking
Cause I'm back, I'm a new var and instantiating
I know that you got a job Bill and Steve
but your company's trust problem's complicating

So GCC won't follow ANSI or copy memory, so let me see
They try to recompile with visual C But it feels so bloated, without C
So, connect with SLIP, or create a RIP Fuck that, write a function, and shift some bits
And get ready, and use a pattern like proxy MS just settled their lawsuits, expect a levy!

Now this looks like a job for C So everybody, just code in C
Cause we need a little, bit more speed Cause it runs so slowly, without C
Now this looks like a job for C So everybody, just code in C
Cause we need a little, bit more speed Cause it runs so slowly, without C

Little Hallions, MS feelin litigious Embarrassed that users still listen to RMS
They start feelin like ellen feiss 'til someone comes on the television and yells SWITCH!!!

A visionary, beard's lookin' scary Could start a revolution, lives in a bear cave
A rebel, although emacs ain't real fast and there's the fact that I only got one class
And it's a disaster, such a castastrophe for you can see so damn much of my class; meant to use C.

Well I'm back, i-j-k-x-y-z-out-ta-var-names Fix your damn indentifier tune your code and I'm gonna
open it, under vim, maybe pico and variables, no such thing as a member
I'm interesting, the best thing since assembly but not Polluting the namespace with inherits
We're Testing, your functions please Feel the tension, soon as someone commits some C
Here's my webpage, my code is free who'll pay the rent? What, You code with vi?

Now this looks like a job for C So everybody, just code in C
Cause we need a little, bit more speed Cause it runs so slowly, without C
Now this looks like a job for C So everybody, just code in C
Cause we need a little, bit more speed Cause it runs so slowly, without C

An object in .NET, I go tit for tat with anybody who's setting this bit, that bit
AT&T, you can get your ass kicked worse than those little C++ bastards

And Ruby? just like a static property not even used with KDE and QT
You're not like C, you're too slow, let go It's over, nobody'll code in OO!
Now let's go, -9's the signal I'll be there with a whole list of XM and L
I use SOAP, XPATH with XSL And you know perl's just like coding in symbols
everybody only just codes C so this must mean, some com-pile-ing
but it's just me i'm obfuscating And though I'm not the first king of controversy
And i'm not the worst thing since assembly but I am the worst thing since 86 XFree
do use BASIC and JSP and used it to get myself wealthy
Here's a concept that works twenty million new coders emerge
but no matter how many fish in the sea half of them can't even code C

Now this looks like a job for C So everybody, just code in C
Cause we need a little, bit more speed Cause it runs so slowly, without C
Now this looks like a job for C So everybody, just code in C
Cause we need a little, bit more speed Cause it runs so slowly, without C

Re:C!

[Jugalator]

by EnglishTim (9662)

You fucking geek.

You must be new h... No, wait...

Re:C!

[Anonymous Coward]

I just HAVE to add this one:

(sorry for the OoO, but else it wouldn't post cause I had to few chars per line)

OoOoOoOoO WRITE IN C
OoOoOoOoO
OoOoOoOoO (sung to The Beatles "Let it Be")
OoOoOoOoO
OoOoOoOoO When I find my code in tons of trouble,
OoOoOoOoO Friends and colleagues come to me,
OoOoOoOoO Speaking words of wisdom:
OoOoOoOoO "Write in C."
OoOoOoOoO
OoOoOoOoO As the deadline fast approaches,
OoOoOoOoO And bugs are all that I can see,
OoOoOoOoO Somewhere, someone whispers"
OoOoOoOoO "Write in C."
OoOoOoOoO
OoOoOoOoO Write in C, write in C,
OoOoOoOoO Write in C, write in C.
OoOoOoOoO LISP is dead and buried,
OoOoOoOoO Write in C.
OoOoOoOoO
OoOoOoOoO I used to write a lot of FORTRAN,
OoOoOoOoO for science it worked flawlessly.
OoOoOoOoO Try using it for graphics!
OoOoOoOoO Write in C.
OoOoOoOoO
OoOoOoOoO If you've just spent nearly 30 hours
OoOoOoOoO Debugging some assembly,
OoOoOoOoO Soon you will be glad to
OoOoOoOoO Write in C.
OoOoOoOoO
OoOoOoOoO Write in C, write in C,
OoOoOoOoO Write In C, yeah, write in C.
OoOoOoOoO Only wimps use BASIC.
OoOoOoOoO Write in C.
OoOoOoOoO
OoOoOoOoO Write in C, write in C,
OoOoOoOoO Write in C, oh, write in C.
OoOoOoOoO Pascal won't quite cut it.
OoOoOoOoO Write in C.
OoOoOoOoO
OoOoOoOoO Guitar Solo
OoOoOoOoO
OoOoOoOoO Write in C, write in C,
OoOoOoOoO Write in C, yeah, write in C.
OoOoOoOoO Don't even mention COBOL.
OoOoOoOoO Write in C.
OoOoOoOoO
OoOoOoOoO And when the screen is fuzzy,
OoOoOoOoO And the editor is bugging me.
OoOoOoOoO I'm sick of ones and zeroes.
OoOoOoOoO Write in C.
OoOoOoOoO
OoOoOoOoO A thousand people people swear that T.P.
OoOoOoOoO Seven is the one for me.
OoOoOoOoO I hate the word PROCEDURE,
OoOoOoOoO Write in C.
OoOoOoOoO
OoOoOoOoO Write in C, write in C,
OoOoOoOoO Write in C, yeah, write in C.
OoOoOoOoO PL1 is 80's,
OoOoOoOoO Write in C.
OoOoOoOoO
OoOoOoOoO Write in C, write in C,
OoOoOoOoO Write in C, yeah, write in C.
OoOoOoOoO The government loves ADA,
OoOoOoOoO Write in C.

That's because 1.4 is the CURRENT version

[the-matt-mobile]

it's clear the author hasn't looked at Java since 1.4

Well, since 1.5 is still in beta , I don't see how this is an invalid comparison.

Re:That's because 1.4 is the CURRENT version

[fforw]

it's clear the author hasn't looked at Java since 1.4

Well, since 1.5 is still in beta , I don't see how this is an invalid comparison.

.. because

The specification and reference compiler are currently at version 0.82, and are expected to reach 1.0 within the year.

So D will reach 1.0 around the release of Java 1.6 Beta.

Re: Fads

[dpbsmith]

Of course.

There are fads in programming just as there are in clothing and management methodologies. And there are always people telling you to adopt the flavor of the month, I mean wave of the future if you don't want to become obsolete.

And you can usually ignore them.

I sat out PL/1, which, well, gee, it had BIG BLUE behind it (in a day when IBM's domination was far more complete than Microsoft's is now). And it doesn't seem to have done me much harm.

True, you can score big by being the person who actually has the "two years experience in" (language-that's-only-existed-for-two-years) that the recruitment ads want, but if you go this route remember that it's easy to be knowledgeable in the latest language if you've just spent some unpaid years in college learning it. If you want to make a career out of always having the skill that's in demand, keep in mind that the only reason the skill is in demand is because it is rare--and you'll need to be quite clever at guessing the next fad, and dedicated about finding out how to educate yourself in it while keeping your day job.

Libraries

[jetkust]

In the end, it may come down to having extensive library support weather this language gets any attention or not. Without having easy to use, easily availiable libraries for sound,graphics,networking etc..., along with support examples and help with the libraries, it may not be worth using the language at all. Sure you can import C/C++ based libraries, but this will all be unmanaged C/C++ code and not protected D code with all the bennifits of D.

Re:Libraries

[Tony Hoyle]

I'm not at all sure how the library compatibility will work in practice... all libraries come with header files, in C, which require a C compiler. Converting them will be nontrivial - especially since they change between versions. You'll end up making D wrapper functions which are no different to Java wrappers or Perl wrappers really.

Nice to see a system language

[wtrmute]

I've seen this language before, and I happen to think it's pretty cool. It's been almost ten years since we've seen a language that isn't compiled to bytecode and interpreted on a VM come out. If I need to write something that compiles to straight Linux ELF/Win32, I'm stuck with C (which I dearly love, but is 34 years old an not even OO) or C++ (g++ gives me terrible headaches, what with refusing to compile code with throw statements), and D is a pretty interesting bare-bones compiling language with very nice features.

Really, kudos to Walter Bright for this little piece. It needn't become popular, if it stays good it's plenty more than enough.

High Hopes

[Randolpho]

Looks like the D website has gotten a facelift since the last time I checked in on the language. I've had high hopes for the concept. I've often felt that C++ needed syntactic a facelift away from C; I especially hate the preprocessor, and am glad D looks to get rid of it.

The only thing about D that bothers me is the inclusion of the Garbage Collector and several other runtime components that occur in the background of your program. I'm not sure I really like that; it sounds a little *too* close to Java, if you get my drift. What I'd really love to see, and what I hope D inspires if not actually implements, is a language with the power of C/C++, but the easier syntax of Java.

D *seems* to be the first step in that direction. I hope it goes further.

Hmmm....

[shrykk]

C has a masssive codebase, and some real code wizards - we're talking people with 30 years experience. There are mature, free compilers avaiable.

Walter Bright's D is free as in beer but not speech, and there's only the one compiler. Do we really need another language that's a bit like C++?

Success is Elusive

[ChaoticCoyote]

D is certainly a very interesting language;

However, there are many interesting languages. Over the years, I've explored Prolog, Modula-2/3, Oberon, Haskell, Ocaml, and others. All of those embody some very interesting concepts; in some cases. they may be "better" than mainstream languages.

But the fact remains that no one has ever paid me (or anyone else I know) to write code in Ocaml, Haskel, Oberon, Prolog, or D. For the most part, it is C, C++, and Java that feed my family; upon occasion, clients need Python and Fortran 95. I'd love to be paid for a project in D or Ocaml; I'm not going to bet the farm on that happening.

I wish the world of languages (both human and computer) was more diverse -- but reality suggests a hard road to popularity for original concepts like D. I respect and appreciate Walter Bright's abilities; his Zortech compiler paved the way for C++, and provided excellent optimization. I wish him luck in promoting his vision.

Wishing for this yesterday

[miyako]

Just yesterday I was thinking about how usefull a language like this would be. Java doesn't run too slowly anymore for most applications, but at times it is just impossible to justify it's slowness compared to a natively compiled language. GCJ seems like a good idea in theory, but doesn't seem to really be going anywhere.
Being able to use pointers if need be is also something really nice about this language that I have found that i really long for in Java at times (not so often to actually use, but oh how much easier it would be to explain the way some things work if pointer wasn't a dirty word in java).
I have not really looked at C# much, but it seems to be freed of many of the complaints about Java (lack of pointers for example), but still has the problem of being a bytecode compiled language running in a VM, and adds the problem of being owned by the company that everyone loves to hate (or at least not trust). AFAIK C# also is not C compatible.
I think these facts leave at least a niche for D, and if it's well done it could soon become one of the DeFacto languages of the future. It seems like development has been going on for quite a while on this, I'm honestly suprised that i've never run across it before, since I have been, mostly out of curiosity, looking for just this. I'm not sure how it will pan out, but I am definitly going to give this new language a shot.

actually, the more important reason for exceptions

[jbellis]

is that when you get an error that is properly handled 3 or 5 or 10 levels out from where the error happens, you DON'T want to have to check for that error in all the intervening calls. Your code would be messy as hell, and what happens more often, as you can see in a LOT of C code out there, is the coder pretends the error just won't happen.

Exceptions let you throw the error where it happens and catch it where it makes the most sense, however far down the stack that may be.

D as Delphi?

[Tuqui]

It will be interesting to see how it compares to Delphi too.

All the C++ programmers are laughing at you...

[Chemisor]

Every once in a while people try to improve on C++. Usually it is those wet-behind-the-ears kids straight out of college who think that because C++ is too hard for them, it is a bad language. But real programmers just shrug and keep on coding in C++. Let the kids have their fun; they'll come around eventually when they want to write some real code. Maybe someday they'll discover that garbage collection is not necessary when you know who owns your memory and encapsulate allocation in logical places, like STL containers. They'll discover that C++ already has overridable operators, full (well, all that matters, anyhow) C compatibility, native compilation (VMs are for script kiddies), inline assembler, and in-built support for unit testing (called a debugger). And as for "Design by Contract", good luck getting any contracts in your new D.

Re:All the C++ programmers are laughing at you...

[rblum]

Yep - totally agree. But the guy behind D is not a wet-behind-the-ears college kid. He wrote one of the first C++ compilers for Zortech.

So if somebody with those credentials thinks there are things we could do better, maybe we should at least take the time to listen to him....

Obsession with C-like syntax

[Bander]

I don't understand why these people keep designing C-like languages that are nothing like C. By the time they are done, the resulting language has so many more features than C, the surface similarity is more of a boondogle than a benefit. While not perfect, C syntax is great for what C is, "human-readable assembly language". When you try to extend it to object oriented systems, the end result is a confusing mess.

There are far better syntax models for an object-oriented programming language than C. I wish people who feel a need to create new languages were willing to base their efforts on a framework more suited to their goals.

Bander (in curmudgeon mode)

A feature every language should have

[bangular]

Speaking of perl...
I really wish lanugages would start implementing the ~ operator from perl (as with $myvar =~ /expression/). From what I understand Ruby also has it. I'm tired of having to deal with pcre's little caveats (as implemented in php, python, java, c, c++ etc.). Such as having to compile the expressions beforehand. Or having to play the backslash game \\\\n to get a newline. There's nothing nicer than being able to have a regular expression that does exactly what I want on one line with minimal code. When programming in perl I tend to use the =~ operater almost as much as the == operator!

D does not have dynamic classloader

[Guardian of Terra]

This is a very very big problem. Plugin problems, binary compatibility problems, DSO problems, vtable format problems, and all other things we hate in C++ and that absent in java/c++

Re:Toss out C.

[Anonymous Coward]

First off, it's link compatability with C. Secondly, no matter how archaic/simple/boneheaded you find C it's still the lingua franca of systems. More so, any system without any link level compatability with C is not really that useful.

Re:Toss out C.

[Jorrit]

I believe it all depends on what you want to do. For most system software (where security is very important) I would agree with you. Also for big application software (like word processing and stuff like that) I would also tend to agree.

However, I'm not sure I agree for software where security is little or no concern but speed is the main issue. One example of that kind of software is games. I'm author of a 3D engine in C++ and I also program in Java for a living. I think that for things like these low-level languages like C and C++ are still the way to go. You can argue that computers are getting faster and faster. But user expectations about what those games can do are also constantly rising.

Greetings,

Ooops

[EnglishTim]

Meant to post that anonymously...

Full C compatibility sucks

[squarooticus]

Being a long-time C++ software engineer (10+ years), the biggest thing that irritates me about C++ is backwards compatibility with C. I would love to have to explicitly cast everything, including between signed and unsigned scalars: in such a case, it is perfectly clear to the programmer when he is performing a type-mismatched comparison or assignment, something that has bitten me often in the past.

In sum: C++'s biggest problem is its C legacy. Tear it away, add real type-safety, and you have a language much more powerful and safer than Java.

Re:actually, the more important reason for excepti

[arkanes]

Checking return values is a horrible use for exceptions. Exceptions are for critical but recoverable errors. "Normal" error conditions shouldn't throw exceptions, not least of which because it makes the code so much nastier and twisting to deal with it. Exceptions are great and allow you to do a type of error handling that would be impossible without them, but I think that some C++ (and especially Java) people get far to enamored of them.

Re:the most interesting part of that table

[Trejkaz]

Troll away, maybe people will start paying attention when the dozens of useful Java libraries are available from C#. *shrug*

What I really need right now though is a nice, clean looking language with access to well-thought-out libraries for image loading/saving and virtual filesystem access. I can't find any of this stuff in a portable form other than on Java, unfortunately. :-(

D WON'T compile C code

[21chrisp]

It's seems that a lot of people are complaining about something that was seriously mis-reported. D CAN'T COMPILE C CODE!! (Sorry for shouting.. but I'm hoping to get peoples' attention). D can link to C binary code.. wow.. what a concept.. almost every programming language can do this. It's almost a requirement for any new language. Without it you would start with 0 code base, and no one will use it. The below text is taken directly from the article. Notice 'Binary Compatibility' and 'Link Compatible.'

Binary C Compatibility:
D programs can import and link against C code and libraries, providing D with free access to a huge amount of pre-written code. Note, however, that D is not link-compatible with C++, so pure C wrappers are required to access C++ code in D.

Personally, I've been praying for years for a language like this to get adopted. Why is it that I can only use full object oriented programming for web/network applications?! Sure.. I know you can do more than this with Java or C#, but is it really practical?? Usually it's just a massive drain on resources. If you need high performance, then you can't do better than C++. Unfortunately, C++ is a transitional language (just look at it's name..). A pure object oriented, fully compilable language that has no VM is desperately needed. I can't believe it's 2004, and such a thing still hasn't been adopted. I hope D (or something like it catches on.. As much as I loved it when it first came out, I'm sick of wrestling with C++ code.

I was hoping for more C

[mnmn]

Garbage collection? Java-like? I thought the world was finally beginning to hate Java.

I'm not sick of C at all. I was hoping for more like ANSI C 04 or something (like ansi c99), more low-level, more control, less objects, less behind-the-scenes crap like garbage collection. The quality of code is always higher with C than C++, unless VERY well programmed with C++, and for that reason alone, C code is reused more despite being less reusable. C++ allows for more cheap right-out-of-college employees, while C gives us quality code that lingers for decades. Think UNIX for a second, and give me an example of something in C++ that has lived so long and so well.

I hate fatter higher-level languages, and we all seem to hate backwards compatibility. If a language has 100 keywords, and you make the next version backwards compatible with 100 more keywords, any sample code can have 200 different keywords in it. Thats making it all tough. C is like RISC, fewer instructions that can be used more creatively, so a smaller amount of code can give you more functionality.

Its all a conspiracy by computer manufacturers. Say you come up with a language that produces binaries slower than Java, all of a sudden a Pentium 3.0GHz with HT is too slow for it, the market keeps pushing for faster and capitalism works. doesnt matter at all that you can run a file/print/mail/application/web server on a 386sx or an ARM MCU 2mm^2 in size running some operating system made in C.

Re:P, not D.

[tpv]

Supposedly B was not actually named after BCPL

See the Wikipedia

Shenanigans

[Anonymous Coward]

features include...garbage collection...full C compatibility

I'll have to call shenanigans on this, as these two features are mutually contradictory (or at least "real" GC is contradictory with full C compatibility).

Now before anyone goes on and on about the existence of GC for C/C++, my definition of "real" GC is that it has to be a NON-conservative, compacting, ephemeral collector. Collectors outside this definition have their place: they help you clean up leaks. But they cannot guarantee two features which are crucial to collectors in any modern language: safety and speed.

Safety. You just can't tell the difference between a pointer and an int in C. Thus there are all sorts of ways of hiding pointers as ints in the language, causing memory leaks. Conversely, if you've encoded a pointer in some way, or have allocated hanging off the edge of a struct (a *very* common occurrance -- Objective-C uses this as its basic objejct storage procedure underneath, or used to) the collector may reap your memory before you're done using it. Ungood.

Speed. One of the things that makes HotSpot kewl is that it moves around memory as it does collection; as a result long-lived objects get compacted together, taking advantage of cache loads. This can't be easily done in GC if it's not allowed to fool with your pointers safely.

The point of garbage collection is to be ubiquitous and invisible. This isn't possible in C/C++.

Re:Toss out C.

[m.koch]

Now on to preprocessor macros. They are useful in statically compiled languages, but in dynamic (VM based) languages they are less than useless. The VM will take any code that it can and inline it, propagate constants, etc.... Macros are not needed.

I think this is more or less a wishlist, at least concerning Java. E.g. using a method in a loop condition has dramatic impact on performance. The Java VM does not determine if a method has no side effects.
Also there is more to a preprocessor than macros.

Re:Toss out C.

[happyfrogcow]

Declare all your variables before executing code

Leads to cleaner code, in my opinion. C++ doesn't require you to do it, but I still do.

declare all your functions before using them

What's the big deal about this? If your tired of typing, you either need to learn to copy/paste, use an IDE that will generate code for you, or find a new industry.

C takes much more time to compoile than Java/C# because all the stupid headers take forever to parse.

Ever hear of "Make" and "Makefiles"? You don't need to keep recompiling things than havn't changed.

Pointers are a problem because they allow unsafe code that forces the hardware to make up for lack of security in the software. Repeat after me, security is a software problem.

Pointers, in some capacity, are needed for low level programming. If you don't need access to hardware, then you might have a reason to consider something besides C.

Dropping multiple inheritance ?

[DerFeuervogel]

While I agree with many of the changes, I think the dropping of multiple inheritance is probably a mistake. This comes in very handy when defining interfaces for object compartmentalization - as in Microsoft's COM.

Re:Dropping multiple inheritance ?

[bradkittenbrink]

Which is why they do include support for interfaces. I don't think you understand the disadvantages of multiple inheritance. I've never found a situation where I actually required the additional functionality that multiple inheritance allows and coudn't be done better with just interfaces. Plus, if you were gonna copy multiple inheritance from c++ you'd need to copy all those nasty casting operators.

Re:Dropping multiple inheritance ?

[shiftless]

Multiple inheritance is awesome and indispensible- when you find a language that implements it well. See Eiffel.

Re:Dropping multiple inheritance ?

[slamb]

I've never found a situation where I actually required the additional functionality that multiple inheritance allows and coudn't be done better with just interfaces.

How about StreamSocket. Okay, multiple inheritance isn't required in the strictest sense, but object-oriented programming isn't, either. MI makes this class make much more sense - it is both a stream and a socket.

In a language providing only support for multiple interfaces, you'd have to reimplement at least one of those in the derived class. You'd probably end up just dispatching all of the calls in the derived class to a shared implementation elsewhere. Not nearly as clean.

Or you could pull a Java and have a getStream() method on the StreamSocket. (Make the caller do the dispatching to the shared implementation.) I don't like it either.

Plus, if you were gonna copy multiple inheritance from c++ you'd need to copy all those nasty casting operators.

I don't see how eliminating MI makes any of them unnecessary:

• static_cast<> - still useful. I like saying "make it an error at compile-time if this can be false". Catching errors earlier = more goodness. C didn't have this, but C didn't ever have a way of knowing one structure could be cast to another safely, since it lacked OOness (inheritance, specifically). Also better performance than a dynamic cast.
• dynamic_cast<> - yup, still useful. A little simplified (it would always return the same actual address or NULL). This is basically what Java's cast is.
• const_cast<> - nothing to do with MI. (Nonexistant in Java because Java doesn't have constness at all.)
• reinterpret_cast<> - nothing to do with MI. Necessary for backwards-compatibility with C stuff.

Google incompatible

[uncadonna]

In addition to D, there's another interesting language called J, not related to Java at all but a descendant of APL. And in today's news there's also a story about X.

Exactly how are we expected to Google for such things?

Please give your projects distinctive names with more than one character, thanks.

It's not entirely closed source

[the_Speed_Bump]

The backend (code generator) for the reference compiler is closed source. However, the frontend is dual-licensed under the GPL or Artistic licenses, and is free in every sense of the word.

David Friedman has already had success connecting this frontend to the GCC code generator, in fact: http://home.earthlink.net/~dvdfrdmn/d

Re:D converts code to C

[digitaldaemon]

No, it compiles natively.
Walter Bright, who also wrote the first native C++ designed the language and wrote to compiler for it. The compiler shares the same backend as his C and C++ compiler.

ManiaC++

OBJECTIVE-C: APPLE VERSION?

[tyrione]

Nice to see once more another myriad of articles that espouse all sorts of wonderful capabilities while either due to ignorance or purposeful deception leaves Apple's Objective-C compiler out of the comparison list.

No matter. All in due course.

Java is fast.

[Kombat]

You have no idea what you're talking about. I have mod points, and already modded in this discussion, but you are spouting such clearly incorrect nonsense that I feel compelled to respond anyway, lest any newbies actually think you know what you're talking about, and repeat your nonsense.

What will you use for your low level device drivers?

C. There you go, congrats, you found one use for C. Now, I ask you: How many low-level device drivers have you written lately? I've never written any, and probably never will. I would wager that over 99% of Slashdot readers are in the same boat as me.

Or how about that code that needs run fast?

Sigh. Go read some benchmarks. JIT-compiled Java is just as fast as C/C++ for virtually everything. You are apparently unaware that compilers have been steadily advancing for several decades now, and are actually extremely sophisticated and smart. They are very good at what they do. When you execute a Java program, nothing is interpreted. It is compiled to optimized native code and executed full-speed.

Actually, in some cases, Java code is faster than C code. When you compile a C program for an x86 platform, you compile to the lowest common denominator. Your compiler cannot assume the presence of advanced instruction sets, like MMX or SSE2. It must restrict itself to outputting code that will run on a 386. A Java interpreter, on the other hand, already knows what platform it is running on, because the native compilation happens at run time, instead of compile time. Thus, it already knows what CPU it is running on, and can take advantage of the precise instruction set availble on the host CPU.

In fact, the java virtual machine and compiler are both written in C.

This was the comment that really had me screaming "You IDIOT!" at my monitor. The Java compiler is written in Java, not C. It lives in com.sun.javac.Main. Go look at the "javac.exe" executable. It's tiny. Know why? Because it's nothing more than a native bootstrapper that executes java com.sun.javac.Main <args>. The interpreter is, in fact, written in C. But the compiler is 100% Pure Java (TM).

Don't believe me? Look disassemble it and look at the code. That should be easy for you, what with your professed experience writing low-level device drivers, eh?

Limbo is the only legitimate successor of C

[CondeZer0]

The clear successor for C is Limbo.

Limbo was developed in Bell Labs by the the same people that created Unix, C, and Plan 9, and someone once described it as "the language the creators of C would have come up with if they had been give and enormous amount of time to fix and improve C", that is exactly what Limbo is.

Dennis M. Ritchie: The Limbo Programming Language
Brian W. Kernighan: A Descent into Limbo

Together with Inferno, Limbo forms the best platform for distributed applications.

Inferno and Limbo were recently released under an open source license and you can download them here:

http://cgi.www.vitanuova.com/cgi-bin/www.vitanuova .com/idown4e.pl

Inferno/Limbo are the only hope for some sanity in the software industry!

Best wishes

uriel

Inaccurate comparison sheet

[AArnott]

Whoever put the comparison sheet of D, Java, C#, C++, and C together needs to be more careful. It claims that C# has no inner classes. Which it currently has. Also the comparison sheet claims many things are unique to D, which in fact are supported by the C# 2.0 specification. "C# 2.0 isn't here yet" you say? Neither is D. In fact, the D spec is only at rev. 0.8x.

Re: Fads

[Decameron81]

I agree with your post on most of your points.

However I just look as this forum and I can't fail to notice that most of the mainstream languages are so because of what they can offer to a certain target of people. For instance you can see how C / C++ remain unbeaten in the low-level programming field. A friend of mine told me perl is used a lot in science (and web programming as well). Something like Java is quite useful for multi-platform development. Visual Basic makes fast development for Windows true. And of course other languages have their purposes too.

So to put it simple, I get the feeling that the future will divide programmers into different fields of programming. Much more than we are split now, that is. So I am not sure that the "wave of the future" will be just one winner, like it's been in the past. I already can see that there are several winners for several different reasons.

My 2 cents,
Diego Rey

Screw More Languages

[4of12]

After Java and C#, why do we need yet another rendition of "what C should have been"?

As far as I'm concerned the standards for C (89,99) are a reasonable place for this language given all its history.

More than anything else we need more standardization of libraries, in the same vein as libc or the STL, but updated to include almost 20 years worth of experience with all kinds of drivers.

• Java provides these and cross-platform which is really nice, but Sun effectively owns final say on the standard.
• Microsoft provides libraries, but MS owns the standard and changes it around for various marketing purposes.
• Apple provides nice libraries, but they own the standard and they don't seem to want to open it up.

Programmers don't need a new language as much as they need powerful, open, standardized, updated libraries.

Re:What about Objective C?

[Zobeid]

As best I recall, both Objective C and C++ were introduced about the same time and for the same purpose: to add OOP support to C. For some reason the marketplace chose C++ and made it successful and widespread while Objective C languished. Why? I have no idea. . . From my admittedly limited experience with both languages, Objective C appears to be a lot easier to work with.

I agree that the world doesn't need yet another extended C. If you're going to build a modern buzzword-compliant language, build it from scratch!

Considering the era C came from, it's a fundamentally good procedural language. Not perfect. Probably not even great. Just good.

In particular, its terse syntax and heavy reliance on operators instead of keywords makes C code dense and hard to read. You can write readable C code, but it takes a conscious effort, some documenting, and some discipline *not* to use every clever coding trick that pops into your mind. (I've read one opinion that C really stands for Clever, because it encourages you to do all sorts of excessively clever things that you'll later regret.)

The reason why the whole software industry seems hell-bent on created mutated versions of C, several decades later, is beyond my understanding.

Re:actually, the more important reason for excepti

[cheide]

Oh! sure, nice, but then the problem is with resources allocated on those 3, 5 or 10 'skipped' levels during exception handling.

Most resources *should* automatically free if they were allocated on the stack, wrapped in an std::auto_ptr, or a guard class whose destructor will do whatever's necessary.

If one of those layers has a resource it knows has the potential to leak anyway, it can add its own exception handler, catch the exception on its way back, release the resource, and then rethrow the exception.

Of course this is still the fundamental problem with languages like C++ -- it works great, *if* you have the discipline to do it properly in the first place...

Nice Comparison

[Elladan]

Heh.

Nice feature comparison, except for the fact that it's wrong. Perhaps the authors of D would do better if they actually learned C++ first? Designing a new language when you're clueless is the first sign of disaster. Look at Java.

Resizeable arrays: D Yes, C++ No

BZZT.

Arrays of bits: D Yes, C++ No

BZZT.

Built-in strings: D Yes, C++ No

BZZT.

Array slicing: D Yes, C++ No

BZZT.

Array bounds checking: D Yes, C++ No

BZZT.

Associative arrays: D Yes, C++ No

It's called a map.

Inner classes: D Yes, C++ No

BZZT (perhaps they meant specifically the automatic parent resolution?)

typeof: D Yes, C++ No

BZZT.

foreach: D Yes, C++ No

BZZT.

Complex and Imaginary: D Yes, C++ No

BZZT.

Struct member alignment control: D Yes, C++ No

Give me a break, every C++ compiler supports this. It's just implementation defined.

Now go look at D's page on Design By Contract in C++: here

Notice that any C++ programmer can come up with a far better implementation than theirs using child class destructors and inlining. In fact, Stroustrup even put one in his book in case you're having trouble getting the brain in gear.

The comparison list combines cluelessness and sophistry ("C++ doesn't have this feature! It's in the STL, not the language" - oh please) to try to promote their own half-baked language.

Conclusion:

Yet another half-baked useless language.

Don't need to imagine -- it was the whole point

[devphil]

Stroustrup is on record many times over as saying that link compatibility with some existing language was a design criterion for him. If not C, then something else.

It is an axiom in the C++ community that compatibility with C is both C++'s greatest strength and its greatest weakness.

The problem with C++

[Animats]

D is Walter Bright's improvement on C++. Bright wrote the original Zortech C++ compiler, which was one of the first real C++ compilers, as opposed to a front-end for a C compiler. D is really too similar to the other C++ variants to get much traction.

C++ itself is undergoing a revision. But the plans for it aren't that good.

The big problem with the C++ committee is that most of the members don't want to admit the language has major problems. Neither does Strostrup, who has written that only minor corrections are needed. If that was really true, we wouldn't need all those variants on C++ (Java, D, C#, Objective-C, Managed C++, etc.)

The committee is dominated by people who like doing cool things with templates. Most of the attention is focused on new features for extending the language via templates. It's possible to coerce the C++ template system into running programs at compile time (see Blitz). Painfully. LISP went down this dead end, where the language was taken over by people who wanted to extend the language with cool macros. (See the MIT Loop Macro.) We all know what happened to LISP.

What isn't happening is any serious attempt to make C++ a safer language. C++ is the the only major language that provides abstraction without memory safety. That's why it causes so much trouble. C++ objects must be handled very carefully, or they break the memory model. This usually results in bad pointers or buffer overflows. Java, etc. are protected against that. This is the basic reason that writing C++ is hard.

It's not fundamentally necessary to give up performance for memory safety. I've written a note on "strict mode" for C++, an attempt to deal with the problem. I'm proposing reference counts with compile-time optimization, rather than garbage collection. The model is close to that of Perl's runtime, which handles this well.

Garbage collection doesn't really fit well to a language with destructors, because the destructors are called at more or less random times. Microsoft's Managed C++ does that, and the semantics of destructors are painful. With reference counts, destructor behavior is repeatable and predictable, so you can allocate resources (open files, windows) in constructors and have things work. The main problem with reference counts is overhead, but with compiler optimization support and a way to take a safe non-reference-counted pointer from a reference counted object, you can get the overhead way down and reference count updates out of almost all inner loops.

C++ itself isn't that bad. The language could be fixed. But I don't see it happening. Microsoft has gone off in a different direction with C#. SGI, HP, DEC, Bell Labs, SCO, and Sun are defunct or in no position to drive standards any more.

What C++ needs is some hardass in a position to slam a fist on the table and say "Fix it so our software doesn't crash all the time". It doesn't have one.

" ... the most important thing

[baudolino]

in the programming language is the name. A language will not succeed without a good name. I have recently invented a very good name and now I am looking for a suitable language." -- D. E. Knuth, 1967

Here's one

[sacrilicious]

I'd like them to come up with a better name [than "D"]

How about "Double-D"? *That* will bring out the programmers in hordes.