From mboxrd@z Thu Jan 1 00:00:00 1970 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on polar.synack.me X-Spam-Level: X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00 autolearn=unavailable autolearn_force=no version=3.4.4 X-Received: by 2002:a24:ed05:: with SMTP id r5-v6mr811591ith.55.1523980392932; Tue, 17 Apr 2018 08:53:12 -0700 (PDT) X-Received: by 2002:a9d:70d7:: with SMTP id w23-v6mr140384otj.4.1523980392744; Tue, 17 Apr 2018 08:53:12 -0700 (PDT) Path: eternal-september.org!reader01.eternal-september.org!reader02.eternal-september.org!feeder.eternal-september.org!news.uzoreto.com!weretis.net!feeder6.news.weretis.net!feeder.usenetexpress.com!feeder-in1.iad1.usenetexpress.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!e130-v6no3053884itb.0!news-out.google.com!15-v6ni3706itg.0!nntp.google.com!e130-v6no3053882itb.0!postnews.google.com!glegroupsg2000goo.googlegroups.com!not-for-mail Newsgroups: comp.lang.ada Date: Tue, 17 Apr 2018 08:53:12 -0700 (PDT) In-Reply-To: <878t9nemrl.fsf@nightsong.com> Complaints-To: groups-abuse@google.com Injection-Info: glegroupsg2000goo.googlegroups.com; posting-host=47.185.233.194; posting-account=zwxLlwoAAAChLBU7oraRzNDnqQYkYbpo NNTP-Posting-Host: 47.185.233.194 References: <1c73f159-eae4-4ae7-a348-03964b007197@googlegroups.com> <878t9nemrl.fsf@nightsong.com> User-Agent: G2/1.0 MIME-Version: 1.0 Message-ID: Subject: =?UTF-8?B?UmU6IEhvdyB0byBnZXQgQWRhIHRvIOKAnGNyb3NzIHRoZSBjaGFzbeKAnT8=?= From: "Dan'l Miller" Injection-Date: Tue, 17 Apr 2018 15:53:12 +0000 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable X-Received-Bytes: 9789 X-Received-Body-CRC: 365693964 Xref: reader02.eternal-september.org comp.lang.ada:51560 Date: 2018-04-17T08:53:12-07:00 List-Id: On Monday, April 16, 2018 at 12:36:03 AM UTC-5, Paul Rubin wrote: > "Dan'l Miller" writes: > > How will Ada use one base of programmers/software-engineers as a basis > > to move onto convincing another group of programmers/software- > > engineers of Ada's advantages? Or is the purpose of Ada to preach to > > its current choir without trying to fill the pews with new > > parishioners? >=20 > I'd like to know why Rust was invented: there was obviously a need for a > safer alternative to C++, but was Ada the answer that everyone simply > overlooked? I keep seeing hints in the Rust community that they are aware of the existe= nce of Ada but have never written a program in Ada because of perceived ins= urmountable time-expenditure/odds/learning-curve. https://www.reddit.com/r/rust/comments/2og8xf/why_rust_started_rather_than_= ada https://www.reddit.com/r/rust/comments/48vh1m/rust_vs_ada https://lwn.net/Articles/547614 http://lambda-the-ultimate.org/node/5277 to pick a few. > I think answering your question would require an informed and critical > comparison between Rust and Ada. I haven't yet found =E2=80=A2that=E2=80=A2 blow-by-blow-narrated feature-co= mparison between Rust and Ada. But regarding =E2=80=9Cneed for a non-garba= ge-collected big-systems language even exists any more=E2=80=9D as you stat= ed below, this book at the URL below is by far the most scathing critique o= f C++2011 and C++2014 (and by inference C++2017). [C++11, C++14, and C++17= are effectively a trilogy that effectively drastically overhauls C++ to be= a rather different language than C++1998 and its bug-fix C++2003.] So Rus= t is one vector of momentum for big-systems languages, going in roughly the= same direction as Ada: safety and de-emphasis of write-once just-barely-w= orking C-language source code. But the resurgence of popularity of C++ is = apparently occurring due to (or in spite of?) an avalanche of new very fini= cky language features that are easy to utilize incorrectly. http://shop.oreilly.com/product/0636920033707.do Scott Meyers _Effective C++_ series books from the 1990s had an over-archin= g message effectively of: =E2=80=98just stay away from these troubled topi= cs in C++ and you'll be just fine.=E2=80=99 But this new book in the serie= s has a drastically different feel and message. It is written in the same = self-help book style as his 1990s books at the level of the surface text, b= ut the subtext for the clever reader with deep-insight reading comprehensio= n is effectively a subversive harsh critique of modern C++. Out of the 42 = gotchas that Meyers explores in breadth & depth, there are numerous places = where Meyers incredulously gasps* how surprising a new feature of C++ is or= behaves. (And I am using =E2=80=98surprise=E2=80=99 there as a pejorative= , as in violations of the Principle of Least Surprise.) * Even though the book is ink-on-paper, the reader can quite clearly hear t= he author's open-mouth drop-jawed gasps in the implied subtext that the aut= hor plasters over with the self-help surface-text. The reason that I bring this up is: there is a sector of the programming/e= ngineering society who thinks that a big-systems language not only needs th= e 42 language features at the heart of Meyers most-recent book in his _Effe= ctive C++_ series, but=E2=80=94more troubling=E2=80=94these 42 language fea= tures need to be messy affairs that need a 300-page book to untangle variou= s knots. Many of these 42 language features in isolation seem to be very m= uch needed to bring C++'s vision into fruition (fixing various gaps, goofs = & gaffs in C++2003), but the reader of _Effective Modern C++_ is easily lef= t with the feeling of: =E2=80=9Coh really?!, certainly some other programm= ing language could tame the beast of these features quite differently and s= till accomplish all the same goals to the same degree of efficiency (and va= stly better correctness and vastly less chance of taking a misstep off the = narrow path through a field of hellfires and landmines).=E2=80=9D > Something with real depth rather than > "verbose vs curly braces". I do know Rust has formal-methods work going > on. Coq-esque and Zed-notation-esque systems of logic need to be the future of = Ada. > I'm not convinced that a need for a non-garbage-collected big-systems > language even exists any more. Obviously low-level, high reliability > realtime programming is important, but they tend to run on small > systems, or else they can be in fairly small subsystems of a bigger > system. Conversely, these aren't small systems in the Commodore-64 sense. These em= bedded systems and tablet computers are 1 or 2 or 3 decimal orders of magni= tude bigger (e.g., DRAM; MIPS; FLOPS in GPUs/physics-processors) than minic= omputers prior to 1990. Low power utilization and augmented-reality common= place in consumer devices begets a prohibition on luxurious interpreted-lan= guage and automatic-garbage-collection techniques. Even IoT devices are ha= ving processors and operating systems and amounts of DRAM that would put so= me minicomputers of that era to shame; those are the same minicomputers tha= t were large systems during the era in which Ada1983 was designed. The vast majority of the new language features in C++{2011, 2014, 2017} fal= l into the category of: the programmer helps the compiler out by declaring= finer-points of programmer-intent so as to evoke various optimizations & e= fficiencies by the compiler. Okay, there is that on one hand. Then on the= other hand, the {OCaml, Swift, Rust, Dart} & even interpreted/JIT-compiled= {Python, Java, Ruby, Perl6} and, yes, even Ada approach is that the compil= er/language-translator can cleverly deduce highly-efficient implementations= without C++{2011, 2014, 2017}'s fine-grained syntactic & semantic construc= ts. It seems the only way for this to be true for Ada is for Ada202X to ha= ve a CoQ-esque or Zed-notation-esque logic-deducing theorem prover in it. = (Indeed, the provably-correct tasking of Ada2020 might need it as well.) It appears that the future is 1) C++{2011, 2014, 2017}'s need for Scott Meyer's _Effective Modern C++_ un= tangling of knots, where the compiler is a happy intelligent dog of sorts w= ho looks to its master to teach the dog new tricks (and to not be malicious= ) versus 2) CoQ-esque or Zed-notation-esque logic-deducing theorem provers grinding = on the source code to effectively have a rigorous argument with the compile= r-theorem-prover about the correctness of the source code as mathematical p= roof, where the compiler-theorem-prover is effectively an automated peer-re= view mechanism of sorts. versus 3) glorified PHP where the language-translator just doesn't care that all t= hat much about strict-enforcement principles & correctness on one hand or s= queezing out efficiency on the other hand, but rather these languages focus= on the programmer adoringly loving to typewrite their source code on a key= board, right down in new editions of the language to even debating which id= entifier names in the standard libraries/frameworks are the very most beaut= iful that programmers would enjoy typewriting. (C#, Java, and Swift seem to= fall into this category.) versus 4) classic cars of yesteryear that don't try to compete with modern cars, b= ut rather just stay refurbished enough to keep running. I am hoping that #4 is not the model for Ada: =E2=80=9CHey, look kids, the= re goes a Model Ada down the road. I haven't seen one of those antiques si= nce I was your age. Wow, we used to think that that Model Ada was what the= future would be like; boy, were we wrong.=E2=80=9D I am very much hoping = that Ada sees #2 above as its emerging mission to extrapolate its current f= oundation of strengths. (I am really really hoping that the Ada1995 era of mimicking C/C++ feature-= set has reached its natural conclusion, so that #1 above is precluded for A= da. In #3 above, I am pretty sure that Swift on iOS/MacOS, C# on Windows, = Java on Android, and Dart on Fuchsia all have the programmers-love-to-typew= rite-me marketspace all locked up on their respective walled gardens; the o= nly question is whether one of them will emerge as cross-platform to the ot= her 3 to then compete in the portability domain with the historically porta= bility-minded languages: C, C++, and Ada.)