Ada is incredibly well designed. One way this shows is that it takes the big, monolithic features of other languages and breaks them down into their constituent parts, so we can choose which portions of those features we want. The example I often reach for to explain this is object-oriented programming.
↫ Christoffer Stjernlöf
Exactly what it says on the tin.
One thing I began to appreciate after 30 years of programming was languages that didn’t need me to type so much, and sadly Ada is FAR from that. Based on Pascal, Ada also inherits “long” words like procedure and function ( and many more ) that you end up typing time and time again for quite frankly, no good reason. In fact, I would argue Ada introduced far more typing to get the same results.
I looked at Ada, I wanted to love it, but I just couldn’t… it’s too much work for small return compared to C/C++. I’d far rather use Pascal with Lazarus-IDE to be honest than Ada… it would be helpful if they shortened down some words.. procedure to proc and function to fn, or func… SOMETHING smaller at any rate!
Yeah, I wonder what would have happened if the Rust people had invested on modernizing Ada instead of reinventing that wheel from scratch.
Xanady Asem,
Ada folks did undertake that challenge with SPARK, which brings the compile time memory safety innovations of Rustlang to Ada.
https://www.adacore.com/languages/spark
There’s been a divide between academic languages and production languages going back decades. It’s obvious that traditional C/C++ code is problematic for writing robust software. Compile time memory verification offers huge steps forward. Moreover more modern languages have addressed a lot of problems with antiquated C/C++ languages, which feels hacky and is a mess for people wanting to build lexical tools. There are very good reasons for academics to want to leave C/C++ behind. And yet doing so comes at a big cost, putting them at odds with the mainstream software industry and huge swaths of developers who don’t want to switch to anything new. This conflict creates barriers for mass adoption.
So although these new language features have tons of merit, the choice of new languages with different syntax has created a very strong headwind that they would not need to fight going with the current instead.
> Ada folks did undertake that challenge with SPARK, which brings the compile time memory safety innovations of Rustlang to Ada.
True, but let’s not imply that bringing borrower-checking to Ada is the whole point of SPARK.
SPARK is a rather minimal subset of Ada chosen to be amenable to formal verification. One of the relatively recent additions to SPARK was a Rust-style borrower-checker.
The Lone OSer,
IMHO it’s a good language with strong academic foundations, but you are right it is more verbose. I have a feeling you’d find that my C code is too verbose as well though 🙂 C’s global namespace and lack of classes are antiquated and problematic, which I tend to compensate for by using longer more descriptive identifiers to make the namespace more manageable – yes they take longer to type.
@The Lone OSer
Since you mention an IDE, what do you make of the argument that verbosity does not matter because you do not type long words: the IDE does it for you?
LeFantome,
That’s a fair question, and I’m curious too.
When it comes to visual studio I find auto-complete to be a mixed bag, at least with C/C++. A very bad trait of these languages is that compiler semantics of an include file can change based on what is being compiled before the include file. So if you just open up an include file without the context of C/C++ file it’s called from, you can get ambiguous results. Such as the way typedef/class/enum/etc declarations will changing the meaning of symbols found in the include file. Or the way the c pre-processor replaces symbols and ifdefs to change the code under different contexts.
The Visual Studio IDE happily lets us open any file. Auto-complete can be such a time saver when it works right, but it doesn’t always parse files with the right context and the result is that autocomplete is incomplete or even wrong, which is infuriating.. Sometimes I find myself having to edit sections that are active in the final project yet the IDE shows them as grayed out (due to ifdefs) or visa versa.
In visual studio, does anyone know of a way to open include files in the context of a specific C file to FORCE it to parse the file exactly as the compiler would? Bare in mind these problems are specific to C/C++ and don’t happen with betters languages like C# that have saner parsing behavior.
RAD tools like Lazarus, Delphi, Visual Studio Toolkit etc. do help relieve the typing absolutely, depending on your project. If you’re doing a lot of UI code it’s a real blessing in fact. However if you’re doing a lot of low level code, say for instance a webapp, a library, or something with a great deal of behind the scenes work – the amount of typing goes up. Auto-completion is awesome in Lazarus, however quite frankly, in Pascal/Ada you don’t just have procedure/function to write a lot, you have BEGIN, END and THEN to write a WHOLE LOT as well… whereas in C {} does the trick.
The Lone OSer,
In fairness key combinations tend to be more difficult to type than a stream of letters from the home position especially on cramped laptops with weird layouts.
Here are some while loops in various languages. Sorry about wordpress formatting!
w3schools.com/c/c_while_loop.php
I agree that pascal constructs are unnecessarily verbose…and I don’t like consuming two lines to begin a loop.
tutorialspoint.com/pascal/pascal_while_do_loop.htm
Not really cheering for VB here, but it can be nice to not require so many parenthesis around everything like in C.
learn.microsoft.com/en-us/dotnet/visual-basic/language-reference/statements/do-loop-statement
Often C devs don’t like rust, but I’d say rust achieves a good balance. It needs fewer parens than C and is probably faster to type.
doc.rust-lang.org/rust-by-example/flow_control/while.html
And of course we can’t forget everyone’s favorite language, cobol!
geeksforgeeks.org/cobol/loop-statements-in-cobol/
Ultimately it comes down to a matter of personal preference 🙂
Your priorities/preferences are at odds with Ada’s design philosophy, so it makes sense you didn’t get along.
Ada’s philosophy is that readability is much more important than writeability, that explicit is better than implicit, and that words should generally be preferred over symbols in the language’s syntax. The first part seems like common sense, especially for ‘serious’ software engineering. The second and third parts are more divisive. I don’t think there’s an objective answer to when explicitness becomes syntactic noise.