I was wondering if there's a big, direct revenue in releasing a programming language such as Java or C#?
Selling IDE's, licensing your brand for books or gaining enterprise prestige seem bit of a marginal benefit to my eyes compared with the effort that undoubtedly the development took (I could be wrong though, of course).
Generally speaking, there is no money in developing programming languages.
C# certainly makes Microsoft money, but it is essentially indirectly making money by promoting the .NET framework and other Microsoft technologies.
It's highly unlikely that one would make any money from programming languages, for the very simple reason that most programming language projects fail miserably - the language ends up being used by its designer (and sometimes not even them) and by nobody else. For every C# or Java there are thousands of languages that went nowhere.
However, language design is fun, so people keep plugging away. And if you do hit it lucky, you can make quite a bit of money. For example, Stroustrup's book The C++ Programming language had sold 500K copies by the time the 3rd ed came out, which means I would guess sales must now be over a million. My 3rd ed. cost me GBP 27.95, and even allowing for publishers and retailers cuts, you can see he must have made a nice bit of change from it!
Certain proprietary languages aimed at specific domains end-up as great "lifestyle" businesses, such as MATLAB (MathWorks) and Mathematica (Wolfram Research). One may also market a language as middleware, like Kx Systems did with q/kdb+ (they sell it as a database rather than a language).
An alternative business model is to provide hosting, like Heroku does for Ruby on Rails. (37Signals effectively ceded that business by not pursuing it.)
And as others have said, a language may be used as a loss leader to lock-in app developers to a specific platform, like C# did for .NET.
Regarding consulting or books, these are pretty limited revenue models; consulting requires a lot of manpower to scale, and books have a saturation point. Better models are hosting or enterprise licenses.
So let's say you want to make a living off writing the next popular language. Assume "making a living" means the equivalent of reasonable pay at a full-time job (any job—not necessarily a technical one). If you really love what you do, you'll probably accept a little bit less to do it, so let's say $12.50 an hour, or $2000/month.
While working a stable job, you release your first version and set up a facility for donations. You then engage in continuous development and marketing, to a degree proportional to the number of users of your language. Let's estimate conservatively that 1% of your users will donate, and each of them will donate an average of $1/year.
That means that in order to get your $2000/month salary, you need to have 2000 donating users for each of the 12 months in the year. That's 2.4 million users total. Let's now assume that it takes 10 years for a language to become this popular: you must therefore acquire an average of 240 000 users per year, or 20 000 users per month.
If you're working the equivalent of full time (160 hours/month), your promotion strategy and implementation quality must be sufficient to gain an average of 125 users per hour. And that's repeat users, of course: if 20% of the people who try your language become repeat users, you actually need a conversion rate of 625 people/hour.
Even if every one of the people you convince directly convinces four more people to try your language—and for the sake of simplicity, assuming that they don't go on to try to convince others—then you're still back down to the 125 users/hour figure.
Now, this may seem totally unreasonable, but believe it or not it can still work: say your marketing strategy produces roughly linear growth over the 10-year period during which your language is gaining ground, and then plateaus. That means at the beginning you'll be converting an average of 0 users/hour, and 10 years later you'll be gaining 250 users. (Again, hourly. Perspective, here.)
That's an average increase of 25 users per hour per year: at the end of each year, you're converting 25 more people per hour—or 4000 more people per month—than you were at the start of the year.
So let's revisit that 2.4 million users ballpark: is it feasible to gain that many users in 10 years? If we accept the (inherently flawed, but usable nonetheless) statistics offered by Langpop as accurate, we get the following information about the top 7 languages currently trending through Yahoo search. If one result is accepted as representative of one user (I know, bear with me), these numbers indicate the rounded approximate average number of users gained per year since the language first appeared.
This puts things back in the realm of possibility: if you make a language that's as popular as, say, Python, then in 20 years you will have enough users to make development and support (and marketing!) of that language into your full-time job.
Make one as popular as C#, and you can do it in 10. Cool!
…Except of course that putting it that way trivialises the vastly unlikely and difficult undertaking that is making a language so popular. But hey, if you've got a good idea, and you can manage to get to the top entirely on your own, without the contributions of any other developers who would take a cut of your donation money, then you're a genius, and you deserve it.
To elaborate on what @Peter said: it is very common for software to be created to support something else. Pretty much anything that is given away for free is used to promote something else, be it advertising, a platform, a device, or a service.
In the case of programming languages it is all about promoting a platform by attracting developers. If you attract developers you get more software written for your platform, and that makes the platform stronger. The way you attract developers is by giving them awesome tools, and the language is one of those tools. In fact, one of Microsoft's strongest cards in their uphill battle to regain their place in the smartphone market is their developer tools. "It's easy to recreate the aps you made for iPhone and Android for Windows Phone 7", "it's easy to make apps written for Windows Phone 7 ready for other screens", etc. etc.
Also, sometimes you're just making a programming language for your own use because you need the tool yourself.
You can get a bit more profit from developing domain-specific "little" languages. Not from selling them, though. There are a few DSLs that sell for a profit, but many more open source successes, and even more failures (both open and closed).
Where you can profit is from the productivity gains you can get from them. There is a kind of development paradigm based around this idea.
The advantages and disadvantages are similar to template-based programming in C++, but more so. For example a DSL requires more up-front work than a normal library, but can give much more flexibility, robustness and "agility" once written. You're unlikely to do it at all unless performance is a big concern, otherwise it's probably easier to delay the work involved until run-time - e.g. use a run-time regular expression based scanning engine instead of a scanner code generator.
"Agility" gets scare quotes because being over-eager to write a DSL is a clear violation of agile principles. Even in a DSL-heavy environment, you're extremely unlikely to work on developing a DSL as part of your everyday routine.
One reason to use a DSL might be to encode some business rules (a kind of expert system specification), and generate code that works with those rules. Because the translation from the declarative business rules to the resulting code can be quite sophisticated, huge changes to the generated code can be handled by making fairly straightforward changes to the business rules specification. For example, the DSL may generate decision trees, or may trace dependencies through a digraph to automatically ensure everything needing re-evaluation is re-evaluated and that there are no cycles (compiled "spreadsheet").
An extreme version of this might be to use a logic language like Prolog for some part of your system, though this is only extreme in a sense - it's also just horses-for-courses language selection rather than a build-your-own-DSL paradigm.
Developing a programming language and standardize them is not really done with a single person. Even Stroustrup is the inventor of C++, there are lot of other industrial experts participating across the world. It's more like a volunteer service. People whom are really talented to write books like Scott Mayers making money out of it. Other people are working as independent consultants or consultants for large organizations.
The best example is the C++ 0x Standardization. It is delayed for years now. The reason why because the committee members either busy with their main work and difficult to make a quorum to finalize the specifications.
Companies like Microsoft Sun(Oracle) has developed their own programming languages and making money from IDE and also by providing seamless support through their platforms. It's more like a closed solution for the problems. But the good things that these programming languages are standardized/approved by ISO or similar committees. Java seems getting selling their IP for companies for using their programming language. Recently Oracle has file sued Google over IP Infringements on Java.
In single sentence, it's more like voluntary service than a business for those who works for open standards.
If you manage (I assume that you mean an individual and not a company) to create a successful programming language it's certainly within the realm of possibility to earn a decent living by selling books, speaking at conferences not to mention consulting or getting acquired or hired. You might even earn money from licensing your programming language to different companies, that will make it less likely to succeed however.
Then again, there's much easier ways to make money and most individuals (corporations like sun and Microsoft excluded) do it more for the challenge and possibly geek cred.
The odds of a small company/individual creating a mainstream programming language are exceedingly small, it's probably easier to try to fill a niché of some kind. Then again, it is certainly not impossible to do so and those who say I can't be done are often interrupted by the ones doing it :)
