To paraphrase Edwin Starr: Wave—what is it good for?
The answer: A little of everything.
Almost nothing else Google has created has generated as much interest, and as much confusion, as Wave. Just describing it to others forces you to pick your words carefully—it's not e-mail, or instant messaging, or a Web chat system, or a message board, or a collaborative-document system, but a hybrid of many features from all of those things.

"Experimental" is the most encompassing word for Wave, in the positive and negative senses of the word. Mitch Wagner believes Wave is one of Google's "concept car" creations—a showcase for a slew of technologies that will eventually be repackaged in other forms. The most crucial being Wave's native protocol, which in theory can be implemented by anyone who wants to write a client or server for it.
In this article I'm going to walk through Wave as it embodies the aspects of a number of other things we should all be familiar with: e-mail, wikis, blogs, instant messaging, online collaboration apps, and many more. In some cases it substitutes quite ably for the item in question; sometimes, it's short of the mark (and not just because the other guy you want to involve in what you're doing doesn't yet have a Wave account).

E-mail
If Wave has been described as any one thing, it's as an e-mail killer—a way to take the inbox/message/threaded-discussion metaphor and push it into an entirely new realm. In many ways, at first glance, Wave does resemble an e-mail client of sorts: there's an inbox, there are folders, and the messages resemble e-mail messages organized into discussion threads.
These design analogies are probably quite deliberate. Most people have trouble working with something that presents absolutely no parallels to what they know and work with—and if there's one environment that even most non-technical people are familiar with, it's an e-mail client (be it Outlook or Google's own Gmail). Others have superficially compared Wave to "Microsoft Outlook / Lotus Notes on steroids," since Outlook (especially in conjunction with Microsoft Exchange) sports a great deal more than just mail: contact management, calendaring, note-taking, etc.

Because Wave is an invitation-only protocol—at least in its current incarnation—that makes it a good deal more secure than e-mail. Conversations are only possible among trusted peers. What's not present is a sense that Wave can be transitional—e.g., you can't take your existing e-mail and slurp it up into Wave. Maybe this isn't so bad, since it further underscores the difference between the two, and since Wave itself is not at this time intended to eclipse other, more broadly accepted things.
Perhaps Google's stance with such things is that they will provide just enough API-level functionality to allow other people to mortar over those gaps. Example: a third-party bot allows people to be automatically notified by e-mail when changes are made to a given conversation. A good idea, but it's something that belongs in Wave by default—especially this early on in Wave's evolution.

Discussion Boards
Another commonplace metaphor Wave emulates is that of a threaded discussion board or USENET group. Unlike the former, though, all Wave discussions are inherently moderated to some degree: people can only participate in a discussion on your explicit invitation. Unlike the latter, though, simply having a Web browser isn't enough: the other person also needs to have a Wave account.
One thing Wave adds to the discussion-board metaphor that isn't available—and which adds to many other aspects of using Wave, too—is the "playback" command. With this, you can see how messages were added, changed, or deleted as if you were pressing the play / fast-forward / rewind buttons on a VCR or DVR. It's an interesting way to see how a given thread has evolved over time, and what directions the conversation may have taken.

Unfortunately, some other things common to message boards are just plain missing. You can't prune and graft message threads, for instance; the only thing remotely close to this is the ability to copy a given message into a whole new wave.
So, again, a lot of what Wave offers is a little too specific to its current incarnation to serve as a substitute for other services. But from what we've seen, the goal isn't so much to substitute for those things as to present analogs to them as ways to allow people to acclimate themselves to the Wave way of doing things.

Wikis / Note-Taking
Another example of this kind of analogous functionality: the way a wave can be used, sort of, as a wiki. Not in the sense that Wave supports wiki-style formatting, but in the more general sense: as a freeform repository for information that can be updated quickly by all participants.
The biggest downside of using Wave as a wiki is the lack of versioning as we have come to know it in Wiki-land. I mentioned how the "replay" function works with conversations, and it has the same function—and the same limitations—when dealing with a conversation that's being used as a generic information store. There's no diff function, as one might find in even the most rudimentary wiki tools. The only way around this right now is to rope in tools from the outside (e.g. a website where you can cut and paste to perform a UNIX-like diff on the texts in question), but that defeats the point of using Wave in the first place, where all the tools should be right in front of you.

One thing Wave's formatting does bring to wiki-style information management is an inherent sense of organization to conversations about a given piece of material. Anyone who's attempted to participate in the "Talk" page for a Wikipedia article quickly understands how difficult it can be to follow or keep track of discussions, as the format for such things is an ad-hoc creation that is not really enforced by the wiki software itself. Wave discussions fall into their native format automatically, so both document and discussion are consistent.

Wave also allows multimedia (at least, a subset of common multimedia types) to be inserted directly into conversations. This allows for that much greater breadth of material to be included, not just plain text or HTML. Note that some document types may be interpreted strangely within the context of a wave: a "classic" Word 97-2003 document, for instance, shows up with the proper icon, but a .DOCX or .ODF document shows up as a .ZIP archive. Experiment before you embed.

Instant Messaging
Many people had plenty of experience with instant messaging even before things like Google Talk ever appeared, but between that and things like Facebook's chat function the concept of an in-browser instant messenger has become familiar territory. Wave isn't a substitute for other instant messaging apps—e.g., AIM—but more like a parallel venue for real-time discussion.
Like instant messaging, wave discussions are logged as they happen, and the other person's typing can register on your own screen in real time. Unlike instant messaging, though, you're not obliged to respond only to the last thing someone posted—or, rather, you can comment contextually on previous posts without the conversation derailing itself. If you and your friends in the discussion have a habit of jumping around or engaging in several parallel discussions at once, using Wave to hold that kind of talk imposes order that would be next to impossible to find through a typical chat client.

...But What Is It, Really?
When Wave first premiered, it was widely rumored that it would replace or eclipse any number of other, existing systems and services. E-mail, mainly: Wave has a high degree of built-in security, while e-mail is natively about as secure as sending a postcard written in pencil.
The more people were able to work with it, however, the clearer it became that Wave wasn't intended as a replacement for many things—and now it's clear that it might not even be intended as an adjunct to them, either. Instead, it's entirely possible that Wave is being used as one of two things.

The first is the "concept car" analogy I mentioned earlier: it's a demonstration of a whole group of different Web 2.0 (and possibly Web 3.0) technologies that could be broken out on their own and put to use in any number of contexts.
The second is a little trickier: Wave is an extended experiment in application interaction—a way to take many common user interface metaphors (e-mail, discussion groups, IMs, etc) and re-implement them in new ways. Most of us are so familiar with the concept of e-mail that any thinking about the way it's put together tends to stop right there: there's an inbox, a spam trap, a list of unread messages, etc. Wave's ingenuity is in taking the outward metaphors of many things we take for granted and combining functionality among things that, on first glance, might not seem to play well with each other.

A programmer friend of mine described Wave as "a research project in human-computer interaction." It makes sense: by creating something a great many people will want to try out in an enthusiastic if also provisional way, Google can figure out which parts of the protocol—both on the backend and in the implementation—are worth developing, and which parts are best left as add-ons by third parties or discarded entirely. And Google's long made a name for itself as a company that creates things that are experimental by their very nature, with their years-long beta cycles.

Because Wave is so amorphous, many things are missing, and many of those omissions are almost certainly by design. One is a way to migrate to Wave—for instance, a tool that would let you take your existing e-mail store and convert it into a set of Wave conversations. No such thing exists right now. Not just because no one's written it, but because Wave itself is a moving target, and so migrating to it would be pointless. The protocol could be nothing like what it is now by the time people other than Google start using it. (In theory one could build Wave servers that run in parallel to one's existing e-mail system, create gateways between the two, and then incrementally migrate the functionality of the latter into the former—but again, why do that when you don't know what you're really migrating to in the first place?)

Another and far bigger issue: Right now, the only version of Wave is Google's Wave. If Wave is meant to be an open protocol that can be implemented by any number of people, either on the client or server side, it'll have to exist in multiple independent implementations before it can be considered any kind of protocol or platform to use in a production sense.
The last word on Wave for now would seem to be that it's aptly named. It's a moving target, and whatever its final incarnation—if there is one—it's likely to only resemble what we have now in the most distant way.