7 ms·
Ada was also ignored because the typical compiler cost tens of thousands of dollars. No open source or free compiler existed during the decades where popular la
by YesThatTom2 6mo ago
Ada was also ignored because the typical compiler cost tens of thousands of dollars. No open source or free compiler existed during the decades where popular languages could be had for free.
I think that is the biggest factor of all.
- twoodfin 6mo agoAda’s failure to escape its niche is overdetermined. Given the sophistication of the language and the compiler technology of the day, there was no way Ada was going to run well on 1980’s microcomputers. Intel built the i432 “mainframe on a chip” with a bunch of Ada concepts baked into the hardware for performance, and it was still as slow as a dog. And as we now know, microcomputers later ate the world, carrying along their C and assembly legacy for the better part of two decades, until they got fast enough and compiler technology got good enough that richer languages were plausible.
- michaelcampbell 6mo agoI used it a bit a Uni and remember enjoying it, but can you say what was slow about it; compilation or runtime or all of it?
- twoodfin 6mo agoI’ve never directly played with Ada but my understanding is that it was very much both. Ada includes a number of critical abstractions that require either dynamic runtime code (slow runtime) or the proverbial sufficiently smart compiler (slow compile-time). These were for good reasons, like safety and the need to define concurrent systems within the language. But they were too heavyweight for the commodity hardware of the era. Nowadays, languages like Go, C++, Java, Rust, … have no trouble with similar abstractions because optimizers have gotten really good (particularly with inlining) and the hardware has cycles to spare.
- sidewndr46 6mo agoI had to take some course that was something like "Programming Language Theory". As a result I had to look at the specifications for dozens of different programming languages. I remember looking at the features of some languages and scratching my head trying to figure out how some of this would ever be practically implemented by a compiler. Later on I found out lots of stuff is just implemented by a runtime anyways, which lead to me realize that those fancy language features are often better as a library.
- cubix 6mo agoI took a course exactly like that. I wonder if we went to the same school, or it’s due to curriculum standardization. The professor was particularly enthusiastic about Ada, so I had assumed the course was largely his creation.
- sidewndr46 6mo agothe accreditation was through ABET at the time from what I recall
- budman1 6mo agoacademics loved ada when it came out. it was a very sophisticated language for it's day. same is true today. the spec/body separation made for an actual delineation between design and implementation.
- deleted 6mo ago[deleted]
- budman1 6mo agocompilation. run time was good, and you could turn off things like run time range checking, if you wanted to.
- shrubble 6mo agoThe first validated compiler for Ada that ran on the IBM PC was released in 1983. The third validated compiler ran on the Western Digital “Pascal MicroEngine” running the UCSD p-system with 64K memory. The MicroEngine executed the byte code from the p-system natively, which was an interesting approach. I think more research is warranted by you on this subject.
- sehugg 6mo agoI sometimes wonder what "Turbo Ada" would have looked like, but I think it would have probably looked like later versions of Borland Pascal. Things like generics and exceptions would have taken some of the "turbo" out of the compiler and runtime -- the code generator didn't even get a non-peephole optimizer until 32-bit Delphi, it would have been too slow. It might be nice to have Ada's tasks driven by DOS interrupts, though. I think GNAT did this.
- jll29 6mo agoI have not seen it, but there is something close to what you ask about: Turbo Modula-2 (an implementation of MODULA-2 written by Martin Odersky), as both MODULA-2 and PASCAL were Niklaus Wirth-invented languages that looks very similar to Ada: "Shortly before we finished our compiler, Borland came out with Turbo Pascal, and they were considering going into the Modula-2 market as well. In fact, Borland decided to buy our Modula-2 compiler to be sold under the name of Turbo Modula-2 for CP/M alongside an IBM PC version they wanted to develop. We offered to do the IBM PC version for them, but they told us they had it already covered. Unfortunately that version took them much longer than planned. By the time it came out, three or four years later, their implementor team had split from the company, and it became known as TopSpeed Modula-2. In the absence of an IBM-PC version, Borland never put any marketing muscle behind Turbo-Modula-2, so it remained rather obscure." -- https://www.artima.com/articles/the-origins-of-scala https://www.artima.com/articles/the-origins-of-scala
- pjmlp 6mo agoSun was the first UNIX vendor to introduce the idea to split UNIX into user and developer SKUs, now Sun eventually also had an Ada compiler. When the companies bought the Solaris Developer tools, that did not include the Ada compiler, that was extra, and wasn't cheap. Having already paid for C, C++, Assembly, why would anyone pay extra for Ada if not obliged to do so?
- eager_learner 6mo agoThis. Nothing can compete with free.
- spauldo 6mo agoThere were effectively no free compilers in the 80s. If you had an expensive UNIX workstation it might come with one, but everyone in the micro world had to pay. Or they wrote in Assembly or a BASIC interpreter. Granted, some were pretty cheap, at least by the early 90s.
- globalchatads 6mo ago[dead]
- acomjean 6mo agoA huge factor. I used ada for years and the fact everyone I worked with did hobby projects in other languages didn’t help it. And most of us liked Ada. It had other warts the string handling wasn’t great, which was a huge problem. It was slow too in a time where that mattered more (we had c and ada in our code base.). I remember the concurrency not using the OSs so the one place we used it was a pain. HPUX had an amazing quasi real time extensions, so we just ran a bunch of processes.
- shrubble 6mo agoThe GNU ADA compiler was first released in 1995: https://en.wikipedia.org/wiki/GNAT https://en.wikipedia.org/wiki/GNAT
- Narishma 6mo agoThat's a decade too late.
- cmrdporcupine 6mo agoLet's just be honest that even if there was a free compiler in 1985 or earlier, there's no way that e.g. someone like Linus Torvalds or an RMS etc would have written various groundbreaking pieces of software on Ada. It was just in an entirely different headspace. I was around then, and culturally there just wasn't this (legitimate) concern with safety in the more "hacker" and Unix community generally. C won headspace at the time precisely because it was minimal and close to the metal while providing the minimum of abstraction people wanted. Which was on the whole fine because the blast radius for mistakes was lower and the machines were simpler.
- tremon 6mo ago> while providing the minimum of abstraction people wanted Yes, I think this is key. I wasn't around in 1985, but on every attempt to write something in Ada I've found myself fighting its standard library more than using it. Ada's stdlib is an intersection of common features found in previous century's operating systems, and anything OS-specific or any developments from the last 30 years seem to be conspicuously absent. That wouldn't be so much of a problem if you could just extend the stdlib with OS-specific features, but Ada's abstractions are closed instead of leaky. I'm sure that this is less of a problem on embedded systems, unikernels or other close-to-hardware software projects where you have more control over the stdlib and runtime; but as much as I like Ada's type system and its tasking model I would never write system applications in Ada because the standard library abstractions just get in the way. To illustrate what I mean, look at the Ada.Interrupts standard library package [0] for interrupt handling, and how it defines an interrupt handler: type Parameterless_Handler is access protected procedure with Nonblocking => False; That's sufficient for hardware interrupts: you have an entry point address, and that's it. But on Linux the same package is used for signal handling, and a parameterless procedure is in no way compatible with the rich siginfo_t struct that the kernel offers. To wit, because the handler is parameterless you need to attach a separate handler to each signal to even know which signal was raised. And to add insult to injury, the gnat runtime always spawns a signal handler thread with an empty sigprocmask before entering the main subprogram so it's not possible to use signalfd to work around this issue either. Ada's stdlib file operations suffer from closed enumerations: the file operations Create and Open take a File_Mode argument, and that argument is defined as [1]: type File_Mode is (In_File, Inout_File, Out_File); -- for Direct_IO type File_Mode is (In_File, Out_File, Append_File); -- for Stream_IO That's it. No provisions for Posix flags like O_CLOEXEC or O_EXCL nor BSD flags like O_EXLOCK, and since enum types are closed in Ada there is no way to add those custom flags either. All modern or OS-specific features like dirfd on Linux or opportunistic locking on Windows are not easily available in Ada because of closed definitions like this. Another example is GNAT.Sockets (not part of Ada stdlib), which defines these address families and socket types in a closed enum: type Family_Type is (Family_Inet, Family_Inet6, Family_Unix, Family_Unspec); type Mode_Type is (Socket_Stream, Socket_Datagram, Socket_Raw); Want to use AF_ALG or AF_KEY for secure cryptographic operations, or perhaps SOCK_SEQPACKET or a SOL_BLUETOOTH socket? Better prepare to write your own Ada sockets library first. [0] https://docs.adacore.com/live/wave/arm22/html/arm22/arm22-C-3-2.html https://docs.adacore.com/live/wave/arm22/html/arm22/arm22-C-... [1] https://docs.adacore.com/live/wave/arm22/html/arm22/arm22-A-7.html https://docs.adacore.com/live/wave/arm22/html/arm22/arm22-A-...
- rhubarbtree 6mo agoStrange comment. GNAT?
- Narishma 6mo agoGNAT was too late to the party.
- jghn 6mo agoGNAT has existed since at least the mid-90s, and in that time period plenty of companies used non-OSS compilers. In that era, the largest blocker for Ada was it ws viewed as having a lot of overhead for things that weren't generally seen as useful (safety guarantees). The reputation was it only mattered if you were working on military stuff, etc.
- adrian_b 6mo agoTrue, but at that time it was already too late. C/C++ had won. Moreover, for a very long time GNAT had been quite difficult to build, configure and coexist with other gcc-based compilers, far more difficult than building and configuring the tool chain for any other programming language. (i.e. you could fail to get a working environment, without any easy way to discover what went wrong, which never happened with any other programming language supported by gcc) I have no idea which was the reason for this, because whichever was the reason it had nothing to do with any intrinsic property of the language. I do not remember when it has finally become easy to use Ada with gcc, but this might have happened only a decade ago, or even more recently.
- budman1 6mo agothe gnat people needed to make a living. there were several impediments to widespread use of gnat, like the runtime license. not that it was their responsibility to provide a free compiler to the masses.
- dharmatech 6mo agoThe ADA compiler for OpenVMS was over $200,000 in the 1990s.
- gosub100 6mo agoProbably because only defense contractors used it. Now imagine that kind of gouging occuring for everything else they spend money on.
- owlstuffing 6mo agoAda was designed to solve different problems in harsher environments than other PLs at the time. Mostly, it was designed for the defense and aeronautics industries and had to compete against other PL designs to become a govt standard, similar to how weapons of war are developed and chosen. Think developing for hardcore code audits. There is no way the language could check all the boxes and remain compatible with, say, Pascal or Modula syntax.
- giancarlostoro 6mo agoI always found it funny when Rust came about, I can't help but feel like, and maybe I'm misremembering when I deep dove Ada the first time, Ada was our first "Rust" like language, maybe Delphi / Pascal is the only other really close one that became mainstream enough before Rust did?
- cmrdporcupine 6mo agoRust emerged from the language enthusiast community not a formal industry committee and in some ways that was its superpower. I and many others have looked at Ada with some appreciation for decades. But the actual "community" around the language was foreign to me; government, defense contractors, etc places that frankly wouldn't even hire me. It's got appealing constructs, and I grew up with the Wirth languages so I wans't put off by its syntax and style... and I even sometimes considered rewriting my OSS C++ pieces in it because I was so desperate for something better. But it was just a self-limiting box.
- giancarlostoro 6mo agoI agree, as someone who is fascinated by it. I worked for a defense contracting company, and no even they used it. It's such a strange gem of a language, so much potential lost.
- jordanb 6mo agoNot really, the state of compilers pretty much sucked back then. GCC was the only real free compiler in the 80s and it wasn't really ready for prime time until the late 80s. You were paying (lots) of money for a compiler no matter what language you chose. And if you were targeting a new language the compiler was sure to suck. Even in the late 90s Jamie Zawinski had a rant against C++. His argument for not using it? The compilers suck! C++ was the main "competitor" of Ada and it was a decade or more behind Ada through most of the time. The "killer feature" of C++ against Ada (when it came to fighting against compiler maturity) was really that you could pretend to be writing C++ code but really just keep writing C-with-classes. If Ada had put a modula or pascal compatibility mode in the language and produced a reference compiler that was based on a stable compiler in one of those languages, the history may have been different because people could have just written "PascAda" while waiting for the compilers to catch up.
- Tangurena2 6mo agoAnd the cpu that was designed to implement ADA also failed miserably: the iAPX 432. https://en.wikipedia.org/wiki/Intel_iAPX_432 https://en.wikipedia.org/wiki/Intel_iAPX_432
- adrian_b 6mo agoThe claim that it was designed for Ada was just marketing hype, like the attempt of today of selling processors "designed for AI". The concept of iAPX 432 had been finalized before Ada won the Department of Defense competition. iAPX 432 was designed based on the idea that such an architecture would be more suitable for high level languages, without having at that time Ada or any other specific language in mind. The iAPX designers thought that the most important feature that would make the processor better suited for high-level languages would be to not allow the direct addressing of memory but to control the memory accesses in such a way that would prevent any accesses outside the intended memory object. The designers have made many other mistakes, but an important mistake was that the object-based memory-access control that they implemented was far too complex in comparison with what could be implemented efficiently in the available technology. Thus they could not implement everything in one chip and they had to split the CPU in multiple chips, which created additional challenges. Eventually, the "32-bit" iAPX432 was much slower than the 16-bit 80286, despite the fact that 80286 had also been contaminated by the ideas of 432, so it had a much too complicated memory protection mechanism, which has never been fully used in any relevant commercial product, being replaced by the much simpler paged memory of 80386. The failure of 432 and the partial failure of 286 (a very large part of the chip implemented features that have never been used in IBM PC/AT and compatibles) are not failures of Ada, but failures of a plan to provide complex memory access protections in hardware, instead of simpler methods based on page access rights and/or comparisons with access limits under software control. Now there are attempts to move again some parts of the memory access control to hardware, like ARM Cheri, but I do not like them. I prefer simpler methods, like the conditional traps of IBM POWER, which allow a cheaper checking of out-of-bounds accesses without any of the disadvantages of the approaches like Cheri, which need special pointers, which consume resources permanently, not only where they are needed.
- 6mo ago
- drob518 6mo agoGiven some of the other issues, I’m not sure it would have mattered, but it certainly didn’t even allow the experiment to be run. I would not have wanted to compile Ada in the 1980s on that hardware. Given all the checking, the compiler must have been horribly slow (imagine compiling Rust on that same 1980s hardware).
- reacweb 6mo agoI was student between 1990 and 1993 and Ada was the main language. Compilation speed was not an issue. I remember that Eiffel was very slow to compile, but not Ada. Between 1994 and 1999, I have worked with Ada on Vax machines. The full recompilation took 2 hours because the machine was slow, not because of the language. Other languages were similarly slow (pascal, C). C was slow because of the lack of precompiled headers (many headers had to be parsed many times). With Ada (alsys ada), there were "libraries" that were black boxes directories containing object code and already parsed package specifications. Between 1999 and 2002, I have handled projects in Ada, C++ and Java. C++ was slightly slower than Ada (slow link). Java was a lots faster. Nowadays, Ada compilation is faster than C++.
- phicoh 6mo agoThe article gives another reason "A second answer is aesthetic. Ada's syntax is verbose in a way that programmers with a background in C find unpleasant. if X then Y; end if; instead of if (x) { y; }. procedure Sort (A : in out Array_Type) instead of void sort(int* a)." I think this should not be underestimated. There is a huge number of small C compilers. People write their own C compiler because they want to have one. That doesn't happen we Ada. Very few people liked Ada enough that they would write a compiler for a subset of the language. For example, an Ada subset similar to the feature set of Modula-2 should be quite doable with a modest effort.
- bigbuppo 6mo agoThe real problem is that Ada forces you to plan ahead and most developers don't really know how to do that.
- phicoh 6mo agoI'd say that is even more so with Rust and Rust got popular in a very short amount of time.
- brabel 6mo agoI think this was a genuine generational change. I am pretty sure Rust would never have become popular 20 years earlier because the priorities back then were so different (that was the era of languages like Ruby and Pearl where conciseness and low verbosity were the most valued aspects).
- budman1 6mo agonot just the priorities, the overall skill and education of programmers. in the 1980/1990's i was a dumb kid. problems of large systems were not in my mind. having to type begin/end instead of {} was, i thought, a valid complaint. with experience, education, and hindsight, most of the advantages of the ada language were not understood by the masses. if ada came out today, it would have taken off just like rust.
- ummonk 6mo agoThat factor was downstream of its complexity though. It's far harder to implement a compiler for Ada 83 than even for modern C.