Why are flat text files the state of the art for representing source code?
Sure - the preprocessor and compiler need to see a flat file representation of the file, but that's easily created.
It seems to me that some form of XML or binary data could represent lots of ideas that are very difficult to track, otherwise.
For instance, you could embed UML diagrams right into your code. They could be generated semi-automatically, and annotated by the developers to highlight important aspects of the design. Interaction diagrams in particular. Heck, embedding any user drawing might make things more clear.
Another idea is to embed comments from code reviews right into the code.
There could be all sorts of aids to make merging multiple branches easier.
Something I'm passionate about is not just tracking code coverage, but also looking at the parts of code covered by an automated test. The hard part is keeping track of that code, even as the source is modified. For instance, moving a function from one file to another, etc. This can be done with GUIDs, but they're rather intrusive to embed right in the text file. In a rich file format, they could be automatic and unobtrusive.
So why are there no IDEs (to my knowledge, anyway) which allow you to work with code in this way?
EDIT: On October 7th, 2009.
Most of you got very hung up on the word "binary" in my question. I retract it. Picture XML, very minimally marking up your code. The instant before you hand it to your normal preprocessor or compiler, you strip out all of the XML markup, and pass on just the source code. In this form, you could still do all of the normal things to the file: diff, merge, edit, work with in a simple and minimal editor, feed them into thousands of tools. Yes, the diff, merge, and edit, directly with the minimal XML markup, does get a tad more complicated. But I think the value could be enormous.
If an IDE existed which respected all of the XML, you could add so much more than what we can do today.
For instance, your DOxygen comments could actually look like the final DOxygen output.
When someone wanted to do a code review, like Code Collaborator, they could mark up the source code, in place.
The XML could even be hidden behind comments.
// <comment author="mcruikshank" date="2009-10-07">
// Please refactor to Delegate.
// </comment>
And then if you want to use vi or emacs, you can just skip over the comments.
If I want to use a state-of-the-art editor, I can see that in about a dozen different helpful ways.
So, that's my rough idea. It's not "building blocks" of pictures that you drag on the screen... I'm not that nuts. :)