Dean Kent (dkent@realworldtech.com) on 3/2/08 wrote:
---------------------------
>Because of the expertise in the shop with assembler, C actually was less efficient
>in terms of developer time.

That is unsurprising and I think will always be the case, regardless of what two technologies you are comparing. There are no silver bullets in software development, and I doubt there will ever be a new tool that is so much of a step-change that new users will be immediately more productive than experienced users of the older technology.

You need to put a bit of effort in to determine whether you will actually be more productive in the long run, how much more productive you will be, how long it will take to get there, and finally, whether it is worth it.

>With extensive use of macros (IBM's macro facility
>is quite advanced and flexible) and reusable modules, there was no advantage to using C for us.

Actually, from what I've seen you post of IBM's macro facility in the past it's dangerously close to C already, so the only real difference is portability. To have a real shot at improving developer time you need a much bigger change than that, although how long it takes to get productive with the new tool may not be worth the effort, and some developers may not even be able to make the transition.

>So - the bottom line is, for a C expert all other languages have limitations.
>The same is true for an assembler expert.

C and assembler also have limitations in that respect; it is not as if going down the language hierarchy you progressively remove limitations, you just have different ones.

>Yet, other languages continue to be developed
>and be popular. Eventually, C will be relegated to the same kind of niche as other
>once popular languages have been, I predict.

For most of us C is already the assembler language of the modern world, and has been for a couple of decades. The big advantage it has over other assembler languages is that it is portable. If you want to write a compiler for a new language, you could do worse than emitting C code. (C++ started that way, and a whole bunch of tools like flex and bison do exactly that.)

All of these languages are Turing-complete, so you can express any program in any of them. It's just a question of how efficiently you can do so. Since C (and, obviously, assembler) allow you to get close to the metal, you can get a very efficient representation for the particular hardware the program is going to run on.

I would hope that language development continues and older languages fall by the wayside, but I don't expect major changes any time soon.

BTW, one interesting observation that my former professor made to me the other day was that it has been a long time since a successful new language came from academia rather than the corporate sector. I also note that the differences between languages has been minor for quite a long time now -- it's like the programming language "Cambrian explosion" ended a few decades ago and all the programming language "body plans" were established during that time, and we've since settled down into a steady evolution of languages that are gradual refinements of those that already exist. (By that I don't mean that the differences between Lisp and C++ are minor, but rather that all the new languages aren't very different from some existing language. There are obviously very good reasons for this, but the downside is that it's even less likely that things will improve radically soon.)