12 ms·

Ada, its design, and the language that built the languages

• turtleyacht 6mo ago
  The next language ought to ensure memory-safe conditions across the network.
  • derleyici 6mo ago
    And the answer is… Rust.
    • anthk 6mo ago
      Or Algol 68, which is doing a comeback.
      • pjmlp 6mo ago
        Or even ESPOL and its evolution, NEWP, never went away, only available to Unisys customers that care about security as top deployment priority.
        • EvanAnderson 6mo ago
          I wish more people knew about the Burroughs Large Systems[0] machines. I haven't written any code for them, but I got turned-on to them by a financial Customer who ran a ClearPath Series A MCP system (and later one of the NT-based Clearpath machines with the SCAMP processor on a card) back in the late 90s, and later by a fellow contractor who did ALGOL programming for Unisys in the mid-70s and early 80s. It seems like an architecture with an uncompromising attitude toward security, and an utterly parallel universe to what the rest of the industry is (except for, perhaps, the IBM AS/400, at least in the sense of being uncompromising on design ideals). [0] https://en.wikipedia.org/wiki/Burroughs_Large_Systems https://en.wikipedia.org/wiki/Burroughs_Large_Systems
          • pjmlp 6mo ago
            Yes, IBM i and z/OS, are the other survivors.
      • deleted 6mo ago
        [deleted]
  • deleted 6mo ago
    [deleted]
  • gostsamo 6mo ago
    the article states that the language can have extensions for different domains, so it is also an option.
  • csrse 6mo ago
    Already exists since way back: https://github.com/mozart/mozart2 https://github.com/mozart/mozart2 (for example)
    • riffraff 6mo ago
      I only realized now CTM is more than 20 years old. In my mind it's still a cool new book. CTM: https://en.wikipedia.org/wiki/Concepts,_Techniques,_and_Models_of_Computer_Programming https://en.wikipedia.org/wiki/Concepts,_Techniques,_and_Mode...
  • yvdriess 6mo ago
    AmbientTalk did this. I used it for a demo where I dragged a mp3 player's UI button to another machine, where pressing play would play it back on the originator's speakers. Proper actor programming in the veins of E and Erlang. https://soft.vub.ac.be/amop/ https://soft.vub.ac.be/amop/
• timschmidt 6mo ago
  It'd be a neat trick to have a single unified language which could bridge the gap between software and hardware description languages.
  • lioeters 6mo ago
    It's an intriguing idea. Having experience with software but almost none (only hobbyist) in hardware, I imagine it'd require a strong type system and mathematical foundation. Perhaps something like Agda, a language that is a proof assistant and theorem prover, with which one can write executable programs. https://en.wikipedia.org/wiki/Agda_(programming_language) https://en.wikipedia.org/wiki/Agda_(programming_language)
    • timschmidt 6mo ago
      I wonder if an escape hatch like Rust's unsafe{} would be enough... a hardware{}. The real complexity likely lies in how to integrate the synthesis tools with the compiler and debugger. The timing model. A memory model like Rust's would certainly aid in assuring predictable behavior, but I'm not certain it would be sufficient.
  • adrian_b 6mo ago
    The hardware description languages, even if they have a single language specification, are divided into 2 distinct subsets, one used for synthesis, i.e. for hardware design, and one used for simulation, i.e. for hardware verification. The subset required for hardware synthesis/design, cannot be unified completely with a programming language, because it needs a different semantics, though the syntax can be made somewhat similar, as with VHDL that was derived from Ada, while Verilog was derived from C. However, the subset used for simulation/verification, outside the proper hardware blocks, can be pretty much identical with a programming language. So in principle one could have a pair of harmonized languages, one a more or less typical programming language used for verification and a dedicated hardware description language used only for synthesis. The current state is not too far from this, because many simulators have interfaces between HDLs and some programming languages, so you can do much verification work in something like C++, instead of SystemVerilog or VHDL. For instance, using C++ for all verification tasks is possible when using Verilator to simulate the hardware blocks. I am not aware of any simulator that would allow synthesis in VHDL coupled with writing test benches in Ada, which are a better fit than VHDL with C++, but it could be done.
• askUq 6mo ago
  From the main page of this website: "These are not positions. They are proposals — structures through which a subject might be examined rather than verdicts about it." The entire site is AI written.
  • graemep 6mo ago
    How is that evidence that the site was AI written?
    • twoodfin 6mo ago
      The evidence is that the article’s writing is terrible. It repeats the same rhetorical devices over and over, dressing up a series of facts in false profundity, because there’s no actual authorial insight here. It’s just “write a well-researched article that demonstrates how ahead of its time the Ada language was” + matmul.
      • boxed 6mo ago
        Humans are not gods of writing that will please all audiences and make no mistakes.
        • twoodfin 6mo ago
          Neither of those standards are what I’m talking about. Obviously this article was highly pleasing to the hn audience as it’s currently sitting at #1. It’s still garbage, because it doesn’t have any interesting ideas behind it. Certainly not commensurate with its length.
    • quietbritishjim 6mo ago
      I think the quoted word salad is plenty of evidence.
    • zozbot234 6mo ago
      The combination of emdashes and inane non-sequiturs in "These are not X. They're Y" style is pretty damning.
• bananaflag 6mo ago
  I am wondering what the Ada equivalent of affine types is. What is the feature that solves the problem that affine types solve in Rust.
  • fweimer 6mo ago
    Limited controlled types probably come closest. https://learn.adacore.com/courses/advanced-ada/parts/resource_management/controlled_types.html https://learn.adacore.com/courses/advanced-ada/parts/resourc...
  • Raphael_Amiard 6mo ago
    There is none as far as affine types go, even is there is a parallel to be made with limited types, but they don’t serve the same purpose. The way Ada generally solves the same problem is by allowing much more in terms of what you can give a stack lifetime to, return from a function, and pass by parameters to functions. It also has the regular « smart pointer » mechanisms that C++ and Rust also have, also with relatively crappy ergonomics
  • ajxs 6mo ago
    The SPARK subset of Ada^1 has a similar kind of move semantics for pointer types^2. 1: SPARK is a formally verifiable subset of Ada: https://en.wikipedia.org/wiki/SPARK_(programming_language) https://en.wikipedia.org/wiki/SPARK_(programming_language) 2: https://arxiv.org/pdf/1805.05576 https://arxiv.org/pdf/1805.05576
  • reirob 6mo ago
    Right from https://www.adacore.com/languages/spark https://www.adacore.com/languages/spark, under the title Memory Safety: Through a combination of mitigation of dynamic memory usage, borrow-checking analysis and advanced formal proof, SPARK formally demonstrates absence of memory issues such as use after free, access to uninitialized memory or memory leaks and corruption.
• spinningslate 6mo ago
  Wonderful article and a good fit with HN’s motto of “move slowly and preserve things” as opposed to Silicon Valley’s jingoistic “move fast and break things”. It highlights the often perplexing human tendency to reinvent rather than reuse. Why do we, as a species, ignore hard-won experience and instead restart? In doing so, often making mistakes that could have been avoided if we’d taken the time or had the curiosity/humility to learn from others. This seems particularly prevalent in software: “standing on the feet of giants” is a default rather than exception. That aside, the article was thoroughly educational and enjoyable. I came away with much-deepened insight and admiration for those involved in researching, designing and building the language. Resolved to find and read the referenced “steelman” and language design rationale papers.
  • cgadski 6mo ago
    Does anyone understand how/why old HN accounts become mouthpieces for language models?
    • spinningslate 6mo ago
      Erm, well, the comment wasn’t AI generated, it was by me - a warts and all human. The sibling comments say TFA is AI generated and I’ll be the first to admit I didn’t spot that. Still found it interesting though.
    • projektfu 6mo ago
      That seems uncharitable.
  • smitty1e 6mo ago
    > Why do we, as a species, ignore hard-won experience and instead restart? Humanity moves from individual to society, not the reverse. Some knowledge moves from the plural to the singular, top to bottom, but the regular existential mode is bottom-up, which point The Famous Article (TFA) makes in the context of programming languages. Children and ideas grow from babe to adult. They do not spring full grown from the brow of Zeus other than in myth.
• ramon156 6mo ago
  off-topic, this article has almost the same theme as dawnfox/dayfox which I love. It fits nicely with my terminal on the left. Cool stuff
• alyls 6mo ago
  The Twitter account is from April 2026: https://xcancel.com/Iqiipi_Essays https://xcancel.com/Iqiipi_Essays There is no named public author. A truly amazing productivity for such a short time period and generously the author does not take any credit.
  • Geezus_42 6mo ago
    No author because its a bot.
    • IAmBroom 6mo ago
      Yes, that was the point.
    • slackfan 6mo ago
      There's a lot of autodidact researchers out there that existed before AI, and AI-assisted, their research and output has sped up significantly. To call them a bot is to mildly put, miss the forest for the trees.
• mhd 6mo ago
  No mention of Algol? Or Mesa?
  • projektfu 6mo ago
    [dead]
• adrian_b 6mo ago
  Ada is a language that had a lot of useful features much earlier than any of the languages that are popular today, and some of those features are still missing from the languages easily available today. In the beginning Ada has been criticized mainly for 2 reasons, it was claimed that it is too complex and it was criticized for being too verbose. Today, the criticism about complexity seems naive, because many later languages have become much more complex than Ada, in many cases because they have started as simpler languages to which extra features have been added later, and because the need for such features had not been anticipated during the initial language design, adding them later was difficult, increasing the complexity of the updated language. The criticism about verbosity is correct, but it could easily be solved by preserving the abstract Ada syntax and just replacing many tokens with less verbose symbols. This can easily be done with a source preprocessor, but this is avoided in most places, because then the source programs have a non-standard appearance. It would have been good if the Ada standard had been updated to specify a standardized abbreviated syntax besides the classic syntax. This would not have been unusual, because several old languages have specified abbreviated and non-abbreviated syntactic alternatives, including languages like IBM PL/I or ALGOL 68. Even the language C had a more verbose syntactic alternative (with trigraphs), which has almost never been used, but nonetheless all C compilers had to support both the standard syntax and its trigraph alternative. However, the real defect of Ada has been neither complexity nor verbosity, but expensive compilers and software tools, which have ensured its replacement by the free C/C++. The so-called complexity of Ada has always been mitigated by the fact that besides its reference specification document, Ada always had a design rationale document accompanying the language specification. The rationale explained the reasons for the choices made when designing the language. Such a rationale document would have been extremely useful for many other programming languages, which frequently include some obscure features whose purpose is not obvious, or which look like mistakes, even if sometimes there are good reasons for their existence. When Ada was introduced, it was marketed as a language similar to Pascal. The reason is that at that time Pascal had become the language most frequently used for teaching programming in universities. Fortunately the resemblances between Ada and Pascal are only superficial. In reality the Ada syntax and semantics are much more similar to earlier languages like ALGOL 68 and Xerox Mesa, which were languages far superior to Pascal. The parent article mentions that Ada includes in the language specification the handling of concurrent tasks, instead of delegating such things to a system library (task = term used by IBM since 1964 for what now is normally called "thread", a term first used in 1966 in some Multics documents and popularized much later by the Mach operating system). However, I do not believe that this is a valuable feature of Ada. You can indeed build any concurrent applications around the Ada mechanism of task "rendez-vous", but I think that this concept is a little too high-level. It incorporates 2 lower level actions, and for the highest efficiency in implementations sometimes it may be necessary to have access to the lowest level actions. This means that sometimes using a system library for implementing the communication between concurrent threads may provide higher performance than the built-in Ada concurrency primitives.
• tromp 6mo ago
  > Every language that has added sum types in the past twenty years has added, with its own syntax, what Ada's designers put in the original standard. While true, that doesn't mean that other language's sum types originated in Ada. As [1] states, > NPL and Hope are notable for being the first languages with call-by-pattern evaluation and algebraic data types and a modern language like Haskell has origins in Hope (from 1980) through Miranda. [1] https://en.wikipedia.org/wiki/Hope_(programming_language) https://en.wikipedia.org/wiki/Hope_(programming_language)
  • adrian_b 6mo ago
    The origin of all sum types is in "Definition of new data types in ALGOL x", published by John McCarthy in October 1964, who introduced the keyword UNION for such types (he proposed "union" for sum types, "cartesian" for product types, and also operator overloading for custom types). John McCarthy, the creator of LISP, had also many major contributions to ALGOL 60 and to its successors (e.g. he introduced recursive functions in ALGOL 60, which was a major difference between ALGOL 60 and most existing languages at that time, requiring the use of a stack for the local variables, while most previous languages used only statically-allocated variables). The "union" of McCarthy and of the languages derived from his proposal is not the "union" of the C language, which has used the McCarthy keyword, but with the behavior of FORTRAN "EQUIVALENCE". The concept of "union" as proposed by McCarthy was first implemented in the language ALGOL 68, then, as you mention, some functional languages, like Hope and Miranda, have used it extensively, with different syntactic variations.
    • tialaramex 6mo ago
      Definitely if you don't have the C "union" user defined type you should use this keyword for your sum types. Many languages don't have this feature - which is an extremely sharp blade intended only for experts - and that's fine. You don't need an Abrams tank to take the kids to school, beginners should not learn to fly in the F-35A and the language for writing your CRUD app does not need C-style unions. If Rust didn't have (C-style) unions then its enum should be named union instead. But it does, so they needed a different name. As we work our way through the rough edges of Rust maybe this will stick up more and annoy me, but given Rust 1.95 just finally stabilized core::range::RangeInclusive, the fix for the wonky wheel that is core::ops::RangeInclusive we're not going to get there any time soon.
• shminge 6mo ago
  I really don't want this to be AI writing because I enjoyed it, but as other commenters have pointed out, the rate of publishing (according to the linked Twitter account) is very rapid. I'm worried that I can't tell.
  • aeve890 6mo ago
    >the rate of publishing (according to the linked Twitter account) is very rapid. I've written almost 50 blog posts in the last 3 years. All in draft, never published mostly because a crippling imposter syndrome and fear of criticism. But every now and then I wake up full of confidence and think "this is it. today I'll click publish I don't give a fuck. All in". Never happens. Maybe this author was in the same boat until a month ago. I know there's a high chance that's just a bot but I can understand if it's not and how devastating has to be to overcome the fear of showing your thoughts to the world and being labeled a bot. If it's not already obvious English is not my first language and I've used LLMs to check my grammar and improve the style. Maybe all my posts smell like chatpgt now and this just adds to the fear of being dismissed as slop.
    • twoodfin 6mo ago
      LLMs do not currently improve the style of typical HN writing. Maybe someday they will; this article is less painfully bad than those of a few months ago. The main problem with this article is that it appears to have been basically written out of whole cloth by the LLM, there’s no novel insight here about Ada beyond what you could fit in a short prompt + the Wikipedia article.
    • OneWingedShark 6mo ago
      Hey, let me encourage you: do it. You might be surprised at the agreement you get, or at discussions.
  • feelamee 6mo ago
    does it really matter? If AI can produce an essay of such quality - take my respect and steal my time please
• DeathArrow 6mo ago
  It looks like OpenClaw started blogging. :D
• 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 ago
    Ada’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 ago
      I 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 ago
        I’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 ago
          I 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.
• donatj 6mo ago
  I like the article overall but the continually repeated 'Language X didn't have that until <YEAR>' is very grating after the first ten or so. I also wish there were concrete code examples. Show me what you are talking about rather than just telling me how great it is. Put some side by side comparisons!
  • microtherion 6mo ago
    You could do the same in reverse as well. Many of the features listed in the first paragraph existed before in other languages, though probably not all of them in a single language. In fact, I believe the design process (sensibly) favored best practices of existing languages rather than completely new and unproven mechanisms. So there was considerable borrowing from PASCAL, CLU, MODULA(-2), CSP. It's possible that the elaborate system for specifying machine representations of numbers was truly novel, but I'm not sure how much of a success that was.
    • adrian_b 6mo ago
      Ada has borrowed nothing from Modula. There are features common to Ada and Modula, but those have been taken by both languages from Xerox Mesa. The first version of Modula was designed with the explicit goal of making a simple small language that provided a part of the features of Xerox Mesa (including modules), after Wirth had spent a sabbatical year at Xerox. Nowadays Modula and its descendants are better known than Mesa, because Wirth and others have written some good books about it and because Modula-2 was briefly widely available for some microcomputers. Many decades ago, I had a pair of UVPROM memories (i.e. for a 16-bit data bus) that contained a Modula-2 compiler for Motorola MC68000 CPUs, so I could use a computer with such a CPU for programming in Modula-2 in the same manner how many early PCs could be used with their built-in BASIC interpreter. However, after switching to an IBM PC/AT compatible PC, I have not used the language again. However, Xerox Mesa was a much superior language and its importance in the history of programming languages is much greater than that of Modula and its derivatives. Ada has taken a few features from Pascal, but while those features were first implemented in Pascal, they had been proposed much earlier by others, e.g. the enumerated types of Pascal and Ada had been first proposed by Hoare in 1965. When CLU is mentioned, usually Alphard must also be mentioned, as those were 2 quasi-simultaneous projects at different universities that had the purpose of developing programming languages with abstract data types. Many features have appeared first in one of those languages and then they have been introduced in the other after a short delay. Among the features of modern programming languages that come from CLU and Alphard are for-each loops and iterators.
• jazzypants 6mo ago
  > JavaScript's module system — introduced in 2015, thirty-two years after Ada's — provides import and export but no mechanism for a type to have a specification whose representation is hidden from importers. What? #1 JavaScript doesn't have formal types. What does it even mean by "representation"? #2 You can just define a variable and not export it. You can't import a variable that isn't exported. There are several little LLM hallucinations like this throughout the article. It's distracting and annoying. Edit: Look, I know that complaining about downvotes is annoying, but I find this genuinely perplexing. Could someone just explain what the hell that paragraph was supposed to mean instead of downvoting me?
• mkovach 6mo ago
  I've written a few small projects in Ada, and it's a better language than it gets credit for. Yes, it's verbose. I like verbosity; it forces clarity. Once you adjust, the code becomes easier to read, not harder. You spend less time guessing intent and more time verifying it. Or verify it, ignore what you verified, then go back and remind yourself you're an idiot when you realize the code your ignored was right. That might just be me. In small, purpose-built applications, it's been pleasant to code with. The type system is strict but doesn't yell at you a lot. The language encourages you to be explicit about what the program is actually doing, especially when you're working close to the hardware, which is a nice feature. It has quirks, like anything else. But most of them feel like the cost of writing better, safer code. Ada doesn't try to be clever. It tries to be clear, even if it is as clear as mud.
• tomekw 6mo ago
  Ada is underrated. I am spending lots of my time writing tons of open source software in Ada, mostly for myself, though.
  • HackerThemAll 6mo ago
    I say the same about FreePascal, but not just for myself. I have deployed some CLI solutions that needed extreme Windows compatibility, from 95 through 98, NT, 2000, XP, ... until the very latest 11 / Server 2025. Only FreePascal compiler provided that easily.
• coldcode 6mo ago
  The US Air Force intended to use ADA, but had to use JOVIAL instead because ADA took so long to be developed. Most people have never heard of JOVIAL but it still exists in the USAF as a legacy. I worked with JOVIAL as part of my first project as a programmer in 1981, even though we didn't even have a full JOVIAL compiler there yet (it existed elsewhere). I remember all the talk about the future being ADA but it was only an incomplete specification at the time.
  • adrian_b 6mo ago
    JOVIAL had been in use within the US Air Force for more than a decade before the first initiative for designing a unique military programming language, which has resulted in Ada. JOVIAL had been derived from IAL (December 1958), the predecessor of ALGOL 60. However JOVIAL was defined before the final version of ALGOL 60 (May 1960), so it did not incorporate a part of the changes that had occurred between IAL and ALGOL 60. The timeline of Ada development has been marked by increasingly specific documents elaborated by anonymous employees of the Department of Defense, containing requirements that had to be satisfied by the competing programming language designs: 1975-04: the STRAWMAN requirements 1975-08: the WOODENMAN requirements 1976-01: the TINMAN requirements 1977-01: the IRONMAN requirements 1977-07: the IRONMAN requirements (revised) 1978-06: the STEELMAN requirements 1979-06: "Preliminary Ada Reference Manual" (after winning the competition) Already the STRAWMAN requirements from 1975 contained some features taken from JOVIAL, which the US Air Force used and liked, so they wanted that the replacement language should continue to have them. However, starting with the IRONMAN requirements, some features originally taken as such from JOVIAL have been replaced by greatly improved original features, e.g. the function parameters specified as in JOVIAL have been replaced by the requirement to specify the behavior of the parameters regardless of their implementation by the compiler, i.e. the programmer specifies behaviors like "in", "out" and "in/out" and the compiler chooses freely how to pass the parameters, e.g. by value or by reference, depending on which method is more efficient. This is a huge improvement over how parameters are specified in languages like C or C++ and in all their descendants. The most important defects of C++, which have caused low performance for several decades and which are responsible for much of the current complexity of C++ have as their cause the inability of C++ to distinguish between "out" parameters and "in/out" parameters. This misfeature is the reason for the existence of a lot of unnecessary things in C++, like constructors as something different from normal functions, and which cannot signal errors otherwise than by exceptions, of copy constructors different from assignment, of the "move" semantics introduced in C++ 2011 to solve the performance problems that plagued C++ previously, etc.
• phplovesong 6mo ago
  I would never work on projects that ADA is used for. 1. Would never work on "missile tech" or other "kills people" tech. 2. Would never work for (civ) aircraft tech, as i would probably burn out for the stress of messing something up and having a airplane crash. That said, im sure its also used for stuff that does not kill people, or does not have a high stress level.
  • OneWingedShark 6mo ago
    It's actually really great for anything where you want to be more safe/correct, like banking... and the `TASK` construct makes it really nice for naturally multitasking situations. A couple of the people in the community are putting together gamedev tools/engine.
    • OneWingedShark 6mo ago
      Found the link: https://github.com/ada-game-framework https://github.com/ada-game-framework
• mcc1ane 6mo ago
  Every time Ada is mentioned here, I start a quest - how to try it for free on Windows. And every time I fail.
  • GhosT078 6mo ago
    I didn't think these were hard to find: https://ada-lang.io/ https://ada-lang.io/ https://alire.ada.dev/ https://alire.ada.dev/
  • adrian_b 6mo ago
    In the past you could easily use Ada or anything else from Linux under Cygwin. Nowadays, you should be able to use anything from Linux under WSL. In the past using Ada was more painful, because you had to use some old version of gcc, which could clash with the modern gcc used for C/C++/Fortran etc. However, during the last few years these problems have disappeared. If you build any current gcc version, you must just choose the option of having ada among the available languages and all will work smoothly.
  • dfox 6mo ago
    Gnat Studio just works on Windows.
    • GhosT078 6mo ago
      I have been using GNAT Studio (previously GNAT Programming Studio or GPS) on Linux for the last 15 years.
  • CodeArtisan 6mo ago
    Toolchain: https://ada-lang.io/ https://ada-lang.io/ IDE: https://github.com/AdaCore/gnatstudio https://github.com/AdaCore/gnatstudio
• theodorethomas 6mo ago
  Reading the Steelman document is like reading a shopping list of everything that's gone into modern Fortran.
• sardon 6mo ago
  I remember learning ADA at uni in the 90s and not loving it because of the syntax and it being slow to work with. I also remember the Arianne 5 rocket crash in the late 90s being blamed for a software bug, and the software being written in ADA. Now i understand that it was not a pure software issue, but still, all that safety did not prevent the major disaster that it was
  • pyjarrett 6mo ago
    Ariane 5 became one of the most reliable rockets ever made and was used to launch the JWST.
  • jordanb 6mo ago
    The Arianne 5 crash was caused by re-using a module from the Arianne 4 in the new rocket without testing. Management declared the module to be "proven" but it was only designed and proven within the flight envelope of the Arianne 4. The C people tried to blame the crash on Ada's use of exceptions. At the time, exceptions were controversial. The actual crash came after an exception was fired and the C folks insisted that C would have just ignored the error state and carried on. Except that the exception was actually the software manifestation of a hardware signal that would have crashed a C program as well. Ada had a lot of haters, mainly because it was imposed top-down in a lot of organizations. But also because there was a lot of money behind C and other technologies. C++ was vaporware at the time and was able to promise to be a better version of everything Ada was (just you wait!). Personally Ada was the coolest language I've ever learned and I still love playing with it.
• 09553221465 6mo ago
  [dead]
  • 09553221465 6mo ago
    [dead]
• 09553221465 6mo ago
  [flagged]
• 09553221465 6mo ago
  [dead]
• 09553221465 6mo ago
  [dead]
• drob518 6mo ago
  > The verbosity was deliberate — Ichbiah wanted programs to be readable by people other than their authors, and readability over time favours explicitness — but it was experienced as bureaucratic and un-hacker-like, and the programming culture that formed in the 1980s and 1990s was organised around the proposition that conciseness was sophistication. Ada was the language of procurement officers. C was the language of people who understood machines. The cultural verdict was delivered early and never substantially revisited. IMO, this was the telling paragraph.
  • jordanb 6mo ago
    Not really. That was written by someone who doesn't really know the language and is writing from a position of hearsay. Ada is "verbose" in that it has fairly rigorous type specification. It was verbose in comparison to languages that had weak or primitive typing. A lot of the "bureaucracy" in the language is being very specific about types to catch bugs. Ada 83 did have a problem in that it lacked [interfaces]. This could sometimes limit code reuse. Ada was designed to be "readable" but so was Pascal and many other languages (and, more recently for instance, Python). "Readability" in those days mainly meant preferring keywords over operators and allowing for infix notation with proper order-of-operations.
    • csb6 6mo ago
      Ada 83 did have generics - maybe you meant OOP support? That wasn't added until Ada 95.
      • jordanb 6mo ago
        I misspoke I actually meant interfaces. Ada forbade multiple inheritance to avoid the diamond problem but Java implemented interfaces as a solution and Ada adopted them. https://www.adaic.org/resources/add_content/standards/05rat/html/Rat-2-4.html https://www.adaic.org/resources/add_content/standards/05rat/...
    • mcc1ane 6mo ago
      https://ada-lang.io/docs/learn/lang/being-more-terse https://ada-lang.io/docs/learn/lang/being-more-terse
• hackrmn 6mo ago
  The article states, quoting: "JavaScript's module system — introduced in 2015, thirty-two years after Ada's — provides import and export but no mechanism for a type to have a specification whose representation is hidden from importers." Then: "in Ada, the implementation of a private type is not merely inaccessible, it is syntactically absent from the client's view of the world." Am I missing something -- a JavaScript module is perfectly able to declare a private element by simply not exporting it, accomplishing what the author prescribes to Ada as "is not merely inaccessible, it is syntactically absent from the client's view of the world"? Same would go for some of the other language author somewhat carelessly lumps together with JavaScript. I loved the article, and I have always had curiosity about Ada -- beyond some of the more modern languages in fact -- but I just don't see where Ada separates interface from implementation in a manner that's distinctly better or different from e.g. JavaScript modules.
  • wrs 6mo ago
    Assuming we’re talking about TypeScript here, because JavaScript doesn’t have exportable types… Any instance in JavaScript, whether or not its type is exported, is just an object like any other, that any other module is free to enumerate and mess with once it receives it. In Ada there are no operations on an instance of a private type except the ones provided by the source module. In other words, if module X returns a value x of unexported type T to module Y, code in module Y is free to do x.foo = 42.
    • hackrmn 6mo ago
      * only if `x` is _an object_ (read: has methods) To preempt the obvious: yes, I know _everything_ (nearly) in JavaScript is an object, but a module exporting a `Function` can expect the caller to use the function, not enumerate it for methods. And the function can use a declaration in the module that wasn't exported, with the caller none the wiser about it.
      • ragall 6mo ago
        To expect is different from it being impossible.
• hackrmn 6mo ago
  I find multiple "strange" flaws with the article, even for my appreciation of Ada _and_ the article as an essay: * The article claims only Ada has true separation of implementation vs specification (the interface), but as far as I am able to reason, also e.g. JavaScript is perfectly able to define "private" elements (not exported by an ES6 module) while being usable in the module that declares them -- if this isn't "syntactical" (and semantical) separation like what is prescribed to Ada, what is the difference(s) the article tries to point out? * Similarly, Java is mentioned where `private` apparently (according to the article) makes the declaration "visible to inheritance, to reflection, and to the compiler itself when it checks subclass compatibility" -- all of which is false if I remember my Java correctly -- a private declaration is _not_ visible to inheritance and consequently the compiler can ignore it / fast-track in a subclass since it works much the same as it has, in the superclass, making the "compatibility" a guarantee by much the same consequence I am still reading the article, but having discovered the above points, it detracts from my taking it as seriously as I set out to -- wanting to identify value in Ada that we "may have missed" -- a view the article very much wants to front.
  • twoodfin 6mo ago
    LLMs are weaponized Gell-Mann amnesia when it comes to writing for humans.
    • noahbp 6mo ago
      Unfortunately, you're right. It is LLM-written: https://www.pangram.com/history/8b17aa57-ce1f-4f46-85f4-4db0bd49d48f https://www.pangram.com/history/8b17aa57-ce1f-4f46-85f4-4db0...
      • twoodfin 6mo ago
        I don’t need a tool to tell me that, and if it was a well-written, interesting, accurate essay, I wouldn’t care. But it’s none of those three things. It is, however, the result of a model trained very effectively to give humans—including hn readers—what they want.
      • 6mo ago
• TruffleLabs 6mo ago
  My work on DoD ADA projects tended to focus on DoD STD 2167 (mid to late 1980s). Sadly the review meetings focused on document structure instead of thoughtful software design and analysis. ADA didn't help; it was cumbersome to get working well, and ADA experience in the contracting agencies was low. The waterfall approach made the projects slow to implement. https://en.wikipedia.org/wiki/DOD-STD-2167A?wprov=sfti1 https://en.wikipedia.org/wiki/DOD-STD-2167A?wprov=sfti1
  • budman1 6mo ago
    waterfall and ada. you used to have a thing called preliminary design (i think is specified in 2167A). with ada, you write all the specs. so, all of the packages procedures / functions and visible variables are declared. Feed this to the compiler. Does it compile? If yes, then your design is complete. Implement the bodies during detail design.
• synack 6mo ago
  imo, the real value of Ada/SPARK today is that it enforces a clear split between specification and implementation, which is exactly what your LLM needs. You define the interface, types, pre/post conditions you want in .ads file, then let the agent loose writing the .adb body file. The language’s focus on readability means your agent has no problem reading and cross referencing specs. The compiler and proof tools verify the body implements the spec.
• Kaliboy 6mo ago
  I absolutely love this article. When I was a young lad, must have been 20 I came across some programming books, including programming in Ada. I read so much of it but never wrote a line of code in it, despite trying. Couldn't get the build environment to work. But the idea of contracts in that way seemed so logical. I didn't understand the difference this article underpins though. I learned Java and thought interfaces were the same. Great article, great language.
  • OneWingedShark 6mo ago
    I'm pretty sure you can get the new crate-system to grab/make you a working build. https://alire.ada.dev/ https://alire.ada.dev/
• cestith 6mo ago
  I like Ada. I can’t believe this whole discussion about how types are handled missed the entire ML family of languages. ML, Standard ML, Concurrent ML, Caml, OCaml, and more have structural types, supported and enforced by the compiler. Ada has one of the same primary issues as PL/I, PHP, and Perl. As much as one might like it, it’s a huge language with loads of syntax and semantics baked into the core language. The article keeps saying that’s a selling point. To some extent and to some people that’s true. However, it also touts the annexes as something wonderful. That’s also true, and more true in my opinion. If only more of the language had been in standardized annexes with a smaller core it may have seen far more adoption.
  • init1 6mo ago
    As far as I can tell you cannot create your own bounded Integer/Floating point types in any of the ML languages. That's one example of one of the core Ada type features. Most people have never experienced a type system like Ada and you will be surprised by how it helps you write higher quality software that is also more reliable.
    • deleted 6mo ago
      [deleted]
    • gwerbin 6mo ago
      F# has units, does it not support bounds on those units?
    • cestith 6mo ago
      My CS classes at uni were based in Ada. I doubt I’ll be surprised.
  • jordanb 6mo ago
    Ada isn't a huge language by modern standards. I would say that it's smaller than modern Python and considerably smaller than modern C++. It's also relatively syntax-free preferring keywords and standard library. Ada came "fully specified" in an era when languages were either not formally specified or were much smaller. C wasn't formally specified, for instance, until 1989 (six years after Ada) and the spec was sparse compared to Ada. For instance, Ada put binary compatibility rules into the language while C's standard didn't worry about ABIs at all. Using two different C compilers could create different ABIs because they aren't part of the language spec.
• blueybingo 6mo ago
  but why does "the industry ignored it" hold as the central framing when the actual story seems to be "the DoD mandated it, contractors used it, and it worked fine for exactly what it was built for"? the implicit assumption is that widespread adoption is the metric for a language succeeding, but ada wasnt trying to win over web developers, it was trying to stop missiles from being maintained in 450 incompatible dialects, which... it actaully did?
  • Jtsummers 6mo ago
    > it was trying to stop missiles from being maintained in 450 incompatible dialects, which... it actaully did? No, it didn't. The objective of consolidating DOD systems on Ada failed, the mandate was short-lived and exceptions were broadly available. Why make things up like this?
• slavkomatanovic 6mo ago
  [flagged]
• coldtea 6mo ago
  Not going with C/C++/Rust style brace syntax probably cost them more devs than anything else... Well, that and the proprietary compilers
• adt 6mo ago
  >Ada's deployment domain meant that Ada's successes were invisible. A software project that compiles without error, runs without race conditions, and has been formally verified to satisfy its specification does not generate incident reports or post-mortems or conference talks about what went wrong. Ada's successes — the aircraft that have not crashed, the railway signalling systems that have not failed, the missile guidance software that has not misguided — are invisible precisely because they are successes. Um... this is most certainly not true. Back in the late 1990s and early 2000s, Ada was the language of choice at my Australian university for both computer science and software engineering degrees. I distinctly recall my lecturer telling us a story about a fancy presentation of Ada in military tank (AFV) systems for the DoD. The story goes that during the presentation, in front of a live audience, the presenter AND the audience had to duck after the tank's turret began spinning around and around. The code had entered an infinite loop!
• kensai 6mo ago
  However, even if Ada is amazing and very secure, it could not help avoid at least one airspace disaster, ain't so? https://en.wikipedia.org/wiki/Ariane_flight_V88 https://en.wikipedia.org/wiki/Ariane_flight_V88
  • pedro_caetano 6mo ago
    That is a strange claim, the Ariane accident was a Systems and really a Requirements flaw. Arguably with that spec the same could have happened if they used punched cards or Haskell instead of Ada.
• DrHBK 6mo ago
  I used Ada since 1984/1985 in large projects. We used the Compiler from DEC and from Karlsruhe (with DIANA). The computer behind was a MicroVax. We use Ada still in industry application. Developing, implementation, installation and forget it because its running.
• ameixaseca 6mo ago
  It could be a nice article if it wasn't full of mistakes and incorrect assumptions about mechanisms and their origins, unsubstantiated statements, and so forth. Right now, it sounds like an Ada fanfic - a misinformed one, to be more precise.
• olivier_henley 6mo ago
  Programming in Ada is like going to the gym every day; it keeps you tight and sharp.
• kristianp 6mo ago
  "the language that built the languages" in the title is editorialising here. It's supposed to be referring to Ada, but it doesn't really make sense, nor is it argued in the article.