Ada and Wirth’s languages (including Modula-2) represent fundamentally opposing schools of thought regarding language design, despite their shared ALGOL-60 heritage and partly related syntax.

Ada is in every aspect a much bigger and more powerful (e.g. concerning the ability of the compiler to assist you in writing safe low-level code) language than any of the Wirth languages. Wirth famously criticized Ada as being "uneconomical"; he believed that because Ada’s requirements were so "baroque" and contradictory, the resulting language was inevitably overloaded with features whose marginal benefits did not justify their complexity (https://archive.org/details/Computer_Language_Issue_09_1985-...). But when you e.g. study the Oberon system, you see that it depended on "tricks" (e.g. SYSTEM.PUT/GET, VAR ARRAY of SYSTEM.BYTE) which were not properly integrated in the language concepts and had to be used without any typechecking support by the compiler.

I wish it had a C-like symbolic syntax as opposed to the prose-like one. I believe it would have been adopted more widely.

Ada follows another philosophy than C and many developers. The 1979 Ada Rationale explicitly states "Readability is more important than writability". Jean Ichbiah, the creator of Ada, explained in an interview that "even if it takes a little longer to write it, it is far more important that a program be readable than writable. For 20 years after the program is written, programmers will have to read it to maintain it." This contrasts with the "fire and forget" attitude of many developers, which often manifests as a "write-once" culture, where the primary goal is to get the logic into the machine as quickly as possible, with little regard for the human who must read it later.

The irony is that symbol-based concise code is much easier to read and comprehend compared to blobs of text. Even replacing Do/Begin/End-s with curly braces would help a lot.

This is a common belief among experienced programmers, but it is largely contradicted by empirical science, especially when discussing novices or general maintainability. First, it is not only about syntax, but also about the possibility to explicate the actual intent of the code. Ada offers special syntax for almost every conceivable use case, allowing developers to clearly express their intentions in the code so that others can understand them. And there are also scientific studies which clearly show that explicit words significantly outperform symbol-heavy languages (e.g. https://www.vidarholen.net/~vidar/An_Empirical_Investigation..., https://www.diva-portal.org/smash/get/diva2:1668029/FULLTEXT..., https://www.ime.usp.br/~gerosa/papers/ICPC2018-Legibility.pd...).

I see. Thanks for your explanation.

> Would you say that Ada sits close to Modula 2 philosophically

In the Rationale for the Design of the Ada Programming Language (published as SIGPLAN Notices, June 1979), the design team explicitly lists their influences. Mesa (a language developed at Xerox PARC, where Wirth made his sabbaticals) is cited as a source for the module/package concept. Modula (referring to Modula-1, 1977) is cited in the context of concurrency and low-level hardware access (e.g., handling interrupts, device drivers), and for the general concept of the module as a syntactic unit. From the timeline we can assume that Modula-2 had not arrived at the design team when they released their proposal to the DoD. Notably, Wirth had actually submitted his own proposal to the DoD (the "Yellow" language, via SRI in 1977), though he withdrew it early because he felt the requirements were too complex. Unfortunately, no public specification of the "Yellow" language exists, but it was very likely not Modula-2.