Comment by auvi | Hacker News Reader

Comment by auvi | Hacker News Reader

I first read about Ada in JARGON:

   Ada:: n. A {{Pascal}}-descended language that has been made
   mandatory for Department of Defense software projects by the
   Pentagon.  Hackers are nearly unanimous in observing that,
   technically, it is precisely what one might expect given that kind
   of endorsement by fiat; designed by committee, crockish, difficult
   to use, and overall a disastrous, multi-billion-dollar boondoggle
   (one common description is "The PL/1 of the 1980s"; hackers find
   the exception handling and inter-process communication features
   particularly hilarious).  Ada Lovelace (the daughter of Lord Byron
   who became the world's first programmer while cooperating with
   Babbage on the design of his mechanical computing engines in the
   mid-1800s) would almost certainly blanch at the use her name has
   been latterly put to; the kindest thing that has been said about it
   it is that there is probably a good small language screaming to get
   out from inside its vast, {elephantine} bulk.

Maybe the situation is different now?

The situation hasn't changed, ESR just flat-out never had a good read on Ada. You really cannot take the Jargon file seriously, its author's ignorances are glaring and numerous.

Ada's "elphantine bulk" is smaller than many modern languages, and even some which the Jargon File praises, like Common Lisp. Its inter-process communication and exception handling functionality were relatively forward-thinking at the time and would look familiar to your average Java programmer.

The kindest thing one can say about esr is that he is not as clever as he thinks he is.

Which is also the least kind thing.

Having learned Ada (or rather, taken a class that used Ada) back around 1990, at the time, it was a bloated monstrosity. It's just that over the past 30 years, C++ has bloated to such a size that it now dwarfs Ada (in my opinion).

Now, at the time, I didn't mind Ada (I think I was the only one to not mind it in class), but learning it just after K&R C/ANSI C (C was just recently standardized), it did appear to have quite a bit more overhead than I was used to.

Languages with the kind of constraints (sometimes kicked up to 11) that inspired the term “bondage and discipline languages” [0] have come back into vogue in a big way since the heyday of the Jargon File, and are in many cases the new “languages of choice” [1].

[0] http://catb.org/~esr/jargon/html/B/bondage-and-discipline-la...

[1] http://catb.org/~esr/jargon/html/L/languages-of-choice.html

I remember reading the first entry many years ago and wondering why anyone would want to use a language with type enforcement when you could have duck typing. (I thought of types as something that had been enforced by the lack of expressive power of old languages in which the types were effectively closer to the machine -- like describing the size of a machine word or something.)

Later on I experienced the famous feature of Haskell in which it takes a while to write a valid program that compiles at all, but then the program immediately works correctly the first time and is free of several large classes of bugs.

So yeah, excellent description of that trend!

Edit: another closely related phenomenon is people gaining a new appreciation for formal grammars and formal specifications, understanding how hard parsing problems are and how bad the consequences of underspecification and undefined behavior can be. I imagine in the Jargon File heyday it would have been made fun of to use formal specifications everywhere, but now some of the most successful systems and tools use them to good effect. Maybe there was a "formal methods winter" or "formalism winter" to parallel the AI Winter?

Edit 2: also, as a sibling comment mentions, these tools are much nicer to use now than they were then. Protobuf and friends do something akin to what ASN.1 did, but the tools around them are so much nicer!

My limited experience with dynamic languages vs the more persnickety typed languages is with the former you really really really need unit testing. I found the more type enforcement the less bugs of the sort unit tests catch. I wonder what programmers of that era would have thought is their introduction to dynamic languages was in an environment heavy on TDD and unit tests. Likely not so fond.

Yes, I think there was very much a "formal methods winter", say from about 1985 to 2015; the Jargon File alludes to this in the "DWIM" entry, I think. Essentially, proving tiny programs correct became feasible in the mid-1960s, but only tiny programs were feasible to prove correct until the mid-oughts. Dijkstra died terribly disappointed.

During essentially this entire time period, the scale of what people were programming was growing much faster than the scale of what people could prove correct. If the aspirational task in 1995 was to prove correct a telecom switching system, the aspirational task in 2005 was to prove correct an AJAX frontend in untyped JS with its goofy coercion rules speaking over an unreliable network with MITM proxies to a backend written in untyped PHP, storing its data in a MySQL cluster where it would read from a read slave that was different from (and a poorly characterized latency period behind) the master it was writing to. Since then things have gotten more complicated, but I feel that formal methods have closed a bit of the gap.

However, I don't think of Ada as being a promising part of these developments. It isn't especially formally tractable, and it doesn't even attempt to offer the kinds of safety guarantees that Rust does. Rust, CompCert, seL4, Z3, Haskell, OCaml, and TLA+ seem a lot more promising than Ada. Heck, even Hypothesis is kind of in that category for me.

P.S. I miss you. I hope you're doing well.

Not saying strong typing is good or bad, but I think tools allow strong typing much more conveniently now than when that B&D sentiment was written. Back then, you'd use vi/emacs and have to argue constantly with the type checker until it was placated. Now of course, your IDE will complete based on what's allowed in the Context.You().are.typing and it's more of a correct by construction affair. Ada might have faired differently if those tools existed then.

I think you mean static typing. For instance, Python is strongly and dynamically typed.

Although the editor of the jargon file was confident he was able to speak for all "Hackers", I'm not sure they were ever quite as narrow-minded as he likes to make out.

(Many of the early criticisms of Ada seem a bit silly in hindsight. For example people used to like to make a big thing of it taking three or four years for fully standards-compliant compilers to appear, which seems pretty good going compared to, say, C++98. Similarly, hardware from the early 80s sometimes struggled to compile Ada code efficiently, but it turns out that processors were getting faster rather rapidly around that time.)

Also, something I'd read before (though I can't find a reference now) is that the "design by committee" was that everything filtered through Jean Ichbiah (I think), who acted as benevolent dictator for the design process, and he was careful about the features forming a cohesive whole.

Another thing was a take on the Jargon File entry where a good amount of hacker backlash was due to it being a language forced by the DoD, so of course it is going to be bad.

The situation was not that way even then.

It's a tongue-in-cheek document, made by imbeciles, not some real language evaluation...

The situation remains the same: Jargon file is bad.

Reply on news.ycombinator.com