On Jan 22, 9:53 pm, artifact....@googlemail.com wrote:
> My question is: how come Ada isn't more popular?
I have another hypothesis that involves the way many programmers got started at a young age. For some decades, classes of smart young teenagers have had easy access to computers and amateur tools, and have honed their skills at what most of them called "hacking". They learned to reason in low levels of abstraction. They spent a lot of time in thread-of-execution debugging.
I think that software engineers who started their understanding in that paradigm are a hard sell for Ada. They do have techniques that work and there are plentiful examples of their success, but we Ada guys prefer something different.
There are other ways to come to the software engineering mindset. One way is to want to write interesting essays in the form of executable programs. Ada is one of the finest tools for this task - at least as far as our kind of program is concerned.
I submit Richard as an example - he writes whereof he knows. A few of the other deponents on this conversation are no slouches either.
Martin Dowie wrote: >> What makes a programmer >> like a new language? Usually, someone comes along and says something >> like "Remember that program that we spent two weeks writing in C? >> Here's a Perl implementation that I put together in three hours and >> one-tenth the code." That's never happened with Ada. > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
By the way, I think that the referenced (by above URL) article does not contradict the apparently contested (under-marked) sentence, because circumstances are far too different in several important aspects.
> Most developers (98% in my experience) are coders. Coders like languages like > C that let them code. Then then enjoy spending more time debugging then they > did coding.
> The other 2% are SW engineers. They like languages like Ada.
> Obviously, C and its ilk are going to be more popular than Ada.
Fast-food joints are more popular than regular restaurants. Ada is the equivalent of a nourishing meal rather than a greasy burger. C++ is the equivalent of peanut-brittle. It tastes good at first, then it gets stuck in your teeth, and then it causes your molars to decay.
> Several decades ago, that was definitely true, but is it /still/ true today? > If one measures things by job openings, then COBOL appears to be outpaced by > C++, Java, and C#.
The most recent survey of actual projects that I've seen (in CACM, IIRC) still had COBOL in 1st place.
-- Jeff Carter "Every sperm is sacred." Monty Python's the Meaning of Life 55
> By the way, I think that the referenced (by above URL) article does not > contradict the apparently contested (under-marked) sentence, because > circumstances are far too different in several important aspects.
Could you elaborate? It seemed pretty close to a controlled experiment to me. The students were not specially selected; the problem was the same; only the language and amount of solution made available to the students changed.
-- Jeff Carter "Every sperm is sacred." Monty Python's the Meaning of Life 55
On Jan 23, 4:18 pm, Martin Dowie <martin.do...@btopenworld.remove.com> wrote:
> kevin clinewrote: > > 3. For the same reason that Limburger cheese isn't more popular. Most > > programmers who have tried Ada didn't like it. What makes a programmer > > like a new language? Usually, someone comes along and says something > > like "Remember that program that we spent two weeks writing in C? > > Here's a Perl implementation that I put together in three hours and > > one-tenth the code." That's never happened with Ada. ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Yes, I've read that article. It would really be sad if Ada were not superior to C for a toy problem in embedded control system development, since Ada was designed specifically for that purpose. But the point was that expressiveness drives programmers to new languages, and Ada isn't particularly expressive.
kevin cline writes: > But the point was that expressiveness drives programmers to new > languages, and Ada isn't particularly expressive.
On the contrary, I think that Ada is the most expressive language around. Consider:
procedure Set_Bit_In_Register (At_Address : in System.Address) is type Register is array (1 .. 32) of Boolean; pragma Pack (Register); for Register'Bit_Order use System.High_Order_First; pragma Volatile (Register);
R : Register; for R'Address use At_Address; begin Register (4) := True; end;
The Ada version makes many more things explicit, that are assumed and implicit in C; for example, the size of the register, the fact that the parameter is an address and not a pointer (*), the endianness, and which bit is being set. As 64-bit architectures become prevalent, the hidden assumption that C's "unsigned long" is 32 bits wide is more and more likely to be incorrect.
(*) consider that when we increment the address by one, it then references the next byte; whereas if we increment the pointer by one, it points to the next "unsigned long", i.e. 2, 4 or 8 bytes and not 1 byte further. C makes no distinction between addresses and pointers, lacking expressiveness in a crucial area.
On Tue, 23 Jan 2007 20:09:48 GMT, Jeffrey R. Carter wrote: > adawo...@sbcglobal.net wrote:
>> Turbo Pascal and other alternatives were already in place and >> much cheaper than Ada. A few brave souls tried to compete >> with products such as RR Software's Janus Ada and Meridian's >> AdaVantage, but the full environment (e.g., integrated editors, >> debuggers, etc.) were not in place they were for Turbo Pascal.
> There's always the question of why, given TP's widespread popularity, C > became more popular.
Because C was sufficiently worse. At some point Visual Basic came and superseded both... (:-))
>> 6) Really good compilers began to appear around 1989. By then Ada's reputation >> for being slow, cumbersome, and hard to use had already been firmly set.
> Actually, the DEC Ada compiler of 1984 was pretty good.
Jeffrey R. Carter wrote: > For long term employees, you > should be looking for SW engineers, whom you then train if necessary.
Yes.
> Identifying SW engineers isn't easy
Especially when the management (the hiring guys) are not SWEs themselves.
> but one clue is that SW engineers > generally like Ada once they've been exposed to it.
Sorry, but this is made up of very thin air. What about SWEs that were never exposed to Ada? What about coders that were exposed to Ada but still have no clue?
The only thing that backs up your statement is that an average Ada programmer is probably more competent than an average C programmer, but even though this correlation is statically true, it is not necessarily related to the virtues of any language, but rather to the fact that it requires more self-determination (and therefore professional discipline) to learn Ada in the world where Ada just does not sell (see "How come Ada isn't more popular" thread). Learning C or Java comes for free and the rest is just statistics, not the rule. There *are* SWEs that use other languages.
> This approach has long term cost savings, as Ada results in SW that is > ready for deployment sooner and has far fewer post-deployment errors > than SW in C.
As if these were the only progamming languages in the world. There are ~2500, according to some very conservative estimations, so there is no need to keep comparing just these two. "Ada is good, because it's better than C" - is this the only thing that Ada can offer? :-) With ~2500 languages around just being better than C does not count as any advantage, so I don't understand why do you use this as an argument so often. If you want to sell Ada, compare it to Java or C++ or C#, for example.
> Your SW is ready before your competitors, and is higher > quality.
Just to flame a bit, I can write a database client library in C++ faster than in Ada without compromising its quality (see my recent posts concerning how much fun I've had with [Limited_]Controlled). ;-)
Jeffrey R. Carter wrote: >> Several decades ago, that was definitely true, but is it /still/ true >> today? If one measures things by job openings, then COBOL appears to >> be outpaced by C++, Java, and C#.
> The most recent survey of actual projects that I've seen (in CACM, IIRC) > still had COBOL in 1st place.
Did it cover open-source projects as well? COBOL was popular at the time when development was centralized in big companies, so it was easier to count the number of lines. Today every kid is coding something and it's even hard to estimate how much code is written every day that is just unnoticed. Just having Windows as a major operating system (with milions of development shops shipping software for it) gives a hint that COBOL might not be a winner any longer.
Ludovic Brenta wrote: > If your project consists of general-purpose libraries and you want > them available to as many developers as possible, then your best > choice is C
That's a misconception as well, quite common in an open-source world.
> not only because of compiler availability because, more > importantly, because C makes it easy to call your libraries from other > languages.
> It is a design goal of GNOME, for example, to support many
> languages for application development, and that's why the GTK+ and > GNOME libraries are implemented in C, despite the fact that they are > object-oriented and so would have benefited from an object-oriented > language.
Windows was implemented in C++, and it has C API. Encapsulation is what separates a language choice for the interface and implementation - well, at least to some extent and provided that both languages are easily "bindable". You can even have C API for Ada implementation - pragma Export is just as useful as pragma Import!. In other words, you don't need to use C for implementation part even if you want to have C API for reasons of useability. This is exacly what the open-source guys don't seem to get right.
> > My question is: how come Ada isn't more popular?I have another hypothesis that involves the way many programmers got > started at a young age. For some decades, classes of smart young > teenagers have had easy access to computers and amateur tools, and > have honed their skills at what most of them called "hacking". They > learned to reason in low levels of abstraction. They spent a lot of > time in thread-of-execution debugging.
> I think that software engineers who started their understanding in > that paradigm are a hard sell for Ada. They do have techniques that > work and there are plentiful examples of their success, but we Ada > guys prefer something different.
[...]
Probably one hurdle for Ada is that the "Ada guys", self-called "we, the true Software Engineers" want to keep "their" language for themselves and discourage the "young hackers" even to take a look at it when they mature... :-) You are missing some aspects: - a hacking teenager (I was one) is able to evolve and see that the some previous "hacks" stop quicker working because there too much intrication between I/O, GUI, system, libraries, or the code was too cryptic - it is possible to hack in Ada; no surprise, such programs are the only that compile and run after 10 years sleep, on a new environment; you are happy there was no conditional compilation in the source, whereas other hacks in another language stop a compiler at line 2 or 3... - not having hacked in the young age does not help to program better. If you look at the code of whatever time you see that untalented people program exactly as poorly whatever they did in their young age. You see these same huge chunks of copy-paste style instruction blocks in old Fortran code or recent code of whatever language, with a mix of interactive/non-interactive, mix of abstraction levels; these people find that a subprogram is a kind of magic, so they prefer to activate the copy-paste machine, which they think is safer... If you succeeded in your effort of generation split (drawing Ada on the "old" side, then into the coffin), yes, there would be trouble for that language... ______________________________________________________________ Gautier -- http://www.mysunrise.ch/users/gdm/index.htm Ada programming -- http://www.mysunrise.ch/users/gdm/gsoft.htm
NB: For a direct answer, e-mail address on the Web site!
> Arthur Evans Jr wrote: >> Ada came out at a time when the government in general and the >> defense Department in particular were widely perceived as >> evil. Since Ada was intended to be used to write programs that would >> kill people, some perceived it as inherently evil. Many folks, >> myself included, made the argument that wrenches are used to build >> weapons; should we ban wrenches? Those who had already made up their >> minds couldn't or wouldn't hear that argument.
> These people never seemed to be very concerned about the DOD's > involvement in COBOL, either.
<adawo...@sbcglobal.net> writes: > I recently had the opportunity to teach a beginning class in Java. What I > discovered is that Java is not type safe, <...>
> > Turbo Pascal and other alternatives were already in place and > > much cheaper than Ada. A few brave souls tried to compete > > with products such as RR Software's Janus Ada and Meridian's > > AdaVantage, but the full environment (e.g., integrated editors, > > debuggers, etc.) were not in place they were for Turbo Pascal. > There's always the question of why, given TP's widespread popularity, C > became more popular.
It has to do with the deep unportability of Pascal and (consequence) the fragmentation of Pascal into incompatible dialects. At the time you had Amiga's, Atari's, Mac's; you had MS Windows coming to replace DOS, so a DOS-oriented, Pascal dialect had little chance against C, except for a short time. TP was an extremely fast compiler producing unoptimized code (except some trivial XOR AX,AX's), but with the CPU's frequencies quickly up around 1990, the interest was more targeted to profit from this speed in the compiled code and less to have a couple millions more of LoC compiled per second. ...
> Windows 95 was the 1st widely used OS with support for tasking. Ada (95) > was the only widely available language with support for tasking at the > time. We probably lost a good opportunity to gain more acceptance of Ada > by not including a standard windowing library and promoting Ada as the > best language for taking advantage of Win95's features.
Mmmh I think it was a good idea *not* to include a standard windowing library: then now Ada would be stuck with an outdated standard windowing library. There was also another problem then: the lack of a good but cheap or free compiler. Don't be so pessimistic, Ada's quality only appear with time - and of course with the effort of brave souls. If you say "I'm a smart software engineer, Ada is for me and not for you", you won't help Ada. If you make good, visible, useful open-source software with Ada, you will help. ______________________________________________________________ Gautier -- http://www.mysunrise.ch/users/gdm/index.htm Ada programming -- http://www.mysunrise.ch/users/gdm/gsoft.htm
NB: For a direct answer, e-mail address on the Web site!
Ludovic Brenta <ludo...@ludovic-brenta.org> writes: > kevin cline writes: >> But the point was that expressiveness drives programmers to new >> languages, and Ada isn't particularly expressive.
> On the contrary, I think that Ada is the most expressive language > around.
If I were in the business of language advocacy as some people in this thread obviously are, I'd now cry: "FUD!!"
Anyway, I have to contradict. You'd have to restrict the scope of your statement a bit (to a special application area or a specific subset of all programming languages) for it to become true.
I stipulate that languages with a Hindley-Milner type system and/or functional languages are, in many aspects, more expressive. Even more so, if they have modules, functors and classes (like OCaml) does.
Or consider Haskell which is a VERY expressive language.
Of course it all depends a bit on how you define "expressiveness".
I do not want to denigrate Ada here. But I think judging the place of Ada in the world right is more important (or useful to Ada or the community) than claming ALL the superlatives for Ada.
> procedure Set_Bit_In_Register (At_Address : in System.Address) is > type Register is array (1 .. 32) of Boolean; > pragma Pack (Register); > for Register'Bit_Order use System.High_Order_First; > pragma Volatile (Register);
> R : Register; > for R'Address use At_Address; > begin > Register (4) := True; > end;
>> kevin cline writes: >>> But the point was that expressiveness drives programmers to new >>> languages, and Ada isn't particularly expressive.
>> On the contrary, I think that Ada is the most expressive language >> around.
> If I were in the business of language advocacy as some people in this > thread obviously are, I'd now cry: "FUD!!" [...] > I do not want to denigrate Ada here. But I think judging the place of > Ada in the world right is more important (or useful to Ada or the > community) than claming ALL the superlatives for Ada.
OK, I'll take back what I said above, and replace with "Ada is the most expressive language I know of." I can't comment on Haskell or OCaml because I don't know them well enough.
>> procedure Set_Bit_In_Register (At_Address : in System.Address) is >> type Register is array (1 .. 32) of Boolean; >> pragma Pack (Register); >> for Register'Bit_Order use System.High_Order_First; >> pragma Volatile (Register);
>> R : Register; >> for R'Address use At_Address; >> begin >> Register (4) := True; >> end;
> <cynical mode> > You're sure you're not confusing verbosity with "expressiveness"? :-) > </cynical mode>
No, but there is bound to be some correlation. Expressiveness is the ability to carry a lot of information across to the human programmer as well as to the compiler. Verbosity, or its opposite conciseness, is the density of that information, as in "information units per line of code" or some such ill-defined measure.
Ada is more expressive than C because it allows programmes to express more information. In a way, it is also more concise in that Ada compilers insert all sorts of implicit checks, and in that Ada has built-in constructs like tasking, array slices and return of dynamically-sized objects that require much more lines of code to achieve in C.
But C more concise than Ada in other ways; for example "volatile unsigned long *" does not require a separate type definition, and "{}" takes only 11.765% of the space of "begin; null; end;"
Markus E Leypold wrote: > <adawo...@sbcglobal.net> writes: > > discovered is that Java is not type safe, <...>
> How so? I'd be really intrested to know.
Java adopted a type system (at least for its scalar types) which was about 20 years outdated at the time of Java's creation. There is a lack of an important layer of abstraction resulting from a C and Assembler mindset.
> You're sure you're not confusing verbosity with "expressiveness"? :-)
> </cynical mode>
Let's try :
pragma Remote_Call_Interface;
as an expressiveness example :)
I won't even try to give the equivalent C/C++ code!
Pascal.
--
--|------------------------------------------------------ --| Pascal Obry Team-Ada Member --| 45, rue Gabriel Peri - 78114 Magny Les Hameaux FRANCE --|------------------------------------------------------ --| http://www.obry.net --| "The best way to travel is by means of imagination" --| --| gpg --keyserver wwwkeys.pgp.net --recv-key C1082595
Dr. Adrian Wrigley wrote: >> 2) There's no good, easy, almost automatic C binding generator, although >> the language has well defined mechanisms for C interfacing. Yes, there >> was some generator. No, it is not trivial at present to get it running in >> my experience. There's some effort to have Ada integrated into SWIG; this >> is promising and IMHO an important selling point to newcomers.
> I think this is critical. Why can't we just say:
> with stdio;
> pragma import (C, stdio, "stdio.h");
> and be able to get structs, functions, constants, variables from C in > an obvious and reasonably reliable way?
Jeffrey R. Carter wrote: > artifact....@googlemail.com wrote:
>> My question is: how come Ada isn't more popular?
> Much of what others have posted is good, but I also see:
> Most developers (98% in my experience) are coders. Coders like languages > like C that let them code. Then then enjoy spending more time debugging > then they did coding.
> The other 2% are SW engineers. They like languages like Ada.
> Obviously, C and its ilk are going to be more popular than Ada.
Perhaps we could run an informal poll to see the background of Ada people here.
Peter Hermann <ica...@csv.ica.uni-stuttgart.de> writes: > Markus E Leypold wrote: >> <adawo...@sbcglobal.net> writes: >> > discovered is that Java is not type safe, <...>
>> How so? I'd be really intrested to know.
> Java adopted a type system (at least for its scalar types) > which was about 20 years outdated at the time of Java's creation. > There is a lack of an important layer of abstraction > resulting from a C and Assembler mindset.
So the type system is not rich enough, at least if you come from the Ada world with those interesting subtyping stuff.
But how is Jave not _type safe_?
I believe Luca Cardelli gave a good definition of what type safe means in his paper
>>> kevin cline writes: >>>> But the point was that expressiveness drives programmers to new >>>> languages, and Ada isn't particularly expressive.
>>> On the contrary, I think that Ada is the most expressive language >>> around.
>> If I were in the business of language advocacy as some people in this >> thread obviously are, I'd now cry: "FUD!!" > [...] >> I do not want to denigrate Ada here. But I think judging the place of >> Ada in the world right is more important (or useful to Ada or the >> community) than claming ALL the superlatives for Ada.
> OK, I'll take back what I said above, and replace with "Ada is the > most expressive language I know of." I can't comment on Haskell or > OCaml because I don't know them well enough.
Fine. I agree it's the most expressive one of the "classic" imperative Familie, under which I count FORTRAN, C, C++, Modula, Pascal and so on (forgive me, there is a similarity, so I think it makes sense for a rough classification to put all those languages into a big super-family, as opposed to in example the more or less functional languages from LISP to Haskell).
>> <cynical mode> >> You're sure you're not confusing verbosity with "expressiveness"? :-) >> </cynical mode>
> No, but there is bound to be some correlation. Expressiveness is the > ability to carry a lot of information across to the human programmer > as well as to the compiler. Verbosity, or its opposite conciseness, > is the density of that information, as in "information units per line > of code" or some such ill-defined measure.
Difficult. With time I've learnt to like the type inference and annotations of Ocaml + Haskell and starting to get annoyed by the Pascal style. Here verbosity buys me hardly anything and leaves me with the necessity to state and restate the same thing everywhere. So no: There is a correlation between verbosity and expressiveness, but not a very strict one.
> Ada is more expressive than C because it allows programmes to express > more information. In a way, it is also more concise in that Ada
I admit it has a richer, type system which allows to express more details.
> compilers insert all sorts of implicit checks, and in that Ada has > built-in constructs like tasking, array slices and return of
Those I wouldn't count towards expressiveness, only as more functionality in the standard runtime.
> dynamically-sized objects that require much more lines of code to > achieve in C.
|
